diff --git a/.gitignore b/.gitignore index a9d1e9e80..2770d44c8 100644 --- a/.gitignore +++ b/.gitignore @@ -40,6 +40,8 @@ temp*build*/ /apps/ai-game-creator-shell/src-tauri/resources/codex/win-x64/codex-path/ /apps/ai-game-creator-shell/src-tauri/resources/codex/win-x64/codex-resources/ /apps/ai-game-creator-shell/src-tauri/resources/codex/win-x64/codex-package.json +/apps/ai-game-creator-shell/src-tauri/resources/plugins/ +/plugins/agc-cocos-editor/native/payload/ /apps/ai-game-creator-shell/logs/ /apps/ai-game-creator-shell/.llm-drafts/ /apps/ai-game-creator-shell/game-creator.config.local.json diff --git a/apps/ai-game-creator-shell/.taurignore b/apps/ai-game-creator-shell/.taurignore new file mode 100644 index 000000000..8ec126556 --- /dev/null +++ b/apps/ai-game-creator-shell/.taurignore @@ -0,0 +1,4 @@ +# resources/plugins 由 build.rs 从 plugins/ 复制生成，属于构建产物。 +# 它在 dev 监听范围内，重新生成会让 Tauri dev 误判为源码改动而触发 +# “构建 -> 监听 -> 再构建”的自触发循环。 +resources/plugins/ diff --git a/apps/ai-game-creator-shell/scripts/build-release.mjs b/apps/ai-game-creator-shell/scripts/build-release.mjs index 03a61ba9d..e5f153b68 100644 --- a/apps/ai-game-creator-shell/scripts/build-release.mjs +++ b/apps/ai-game-creator-shell/scripts/build-release.mjs @@ -4,6 +4,11 @@ import fs from 'node:fs'; import path from 'node:path'; import { fileURLToPath } from 'node:url'; +import { + defaultEditorFeatures, + withDefaultCargoFeatures, +} from './cargo-features.mjs'; + const appRoot = fileURLToPath(new URL('..', import.meta.url)); const defaultReleaseTarget = 'x86_64-pc-windows-msvc'; const releaseTarget = @@ -159,10 +164,30 @@ export async function prepareReleaseVersion() { return nextVersion; } -export function runTauriBuild(args = []) { +export function buildTauriBuildArguments( + args = [], + target = releaseTarget, + platform = process.platform, +) { const noBundle = args.includes('--no-bundle'); - const hasTarget = args.includes('--target'); - const targetArgs = noBundle || hasTarget ? [] : ['--target', releaseTarget]; + const targetIndex = args.indexOf('--target'); + const explicitTarget = + targetIndex >= 0 + ? args[targetIndex + 1] + : args + .find((value) => value.startsWith('--target=')) + ?.slice('--target='.length); + const targetArgs = noBundle || explicitTarget ? [] : ['--target', target]; + const features = defaultEditorFeatures( + explicitTarget || (noBundle ? platform : target), + ); + return [ + 'build', + ...withDefaultCargoFeatures([...targetArgs, ...args], features), + ]; +} + +export function runTauriBuild(args = []) { const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm'; const result = spawnSync( npmCommand, @@ -172,9 +197,7 @@ export function runTauriBuild(args = []) { 'exec', 'tauri', '--', - 'build', - ...targetArgs, - ...args, + ...buildTauriBuildArguments(args), ], { cwd: appRoot, stdio: 'inherit', shell: process.platform === 'win32' }, ); diff --git a/apps/ai-game-creator-shell/scripts/cargo-features.mjs b/apps/ai-game-creator-shell/scripts/cargo-features.mjs new file mode 100644 index 000000000..de476e0a7 --- /dev/null +++ b/apps/ai-game-creator-shell/scripts/cargo-features.mjs @@ -0,0 +1,24 @@ +/** 默认桌面能力；显式 feature 参数优先，不把应用参数当 Cargo 参数。 */ +export function withDefaultCargoFeatures(argv, features) { + const separator = argv.indexOf('--'); + const cargoArgs = separator < 0 ? argv : argv.slice(0, separator); + if ( + !features.length || + cargoArgs.some( + (value) => + value === '--features' || + value === '-f' || + value.startsWith('--features=') || + /^-f.+/u.test(value), + ) + ) { + return argv; + } + return [`--features=${features.join(',')}`, ...argv]; +} + +export function defaultEditorFeatures(target) { + return target === 'win32' || target.includes('windows') + ? ['cocos-editor-execute'] + : []; +} diff --git a/apps/ai-game-creator-shell/scripts/cargo-features.test.mjs b/apps/ai-game-creator-shell/scripts/cargo-features.test.mjs new file mode 100644 index 000000000..80e31e9be --- /dev/null +++ b/apps/ai-game-creator-shell/scripts/cargo-features.test.mjs @@ -0,0 +1,49 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; + +import { buildTauriBuildArguments } from './build-release.mjs'; +import { withDefaultCargoFeatures } from './cargo-features.mjs'; + +test('Windows release includes the same editor feature as development', () => { + assert.deepEqual( + buildTauriBuildArguments([], 'x86_64-pc-windows-msvc', 'win32'), + [ + 'build', + '--features=cocos-editor-execute', + '--target', + 'x86_64-pc-windows-msvc', + ], + ); + assert.deepEqual( + buildTauriBuildArguments( + ['--no-bundle'], + 'x86_64-pc-windows-msvc', + 'linux', + ), + ['build', '--no-bundle'], + ); + assert.deepEqual( + buildTauriBuildArguments(['--target=aarch64-apple-darwin']), + ['build', '--target=aarch64-apple-darwin'], + ); +}); +test('explicit Cargo features override defaults in every supported spelling', () => { + for (const args of [ + ['--features', 'custom'], + ['--features=custom'], + ['-f', 'custom'], + ['-fcustom'], + ]) { + assert.deepEqual( + withDefaultCargoFeatures(args, ['cocos-editor-execute']), + args, + ); + } + assert.deepEqual( + withDefaultCargoFeatures( + ['--', '--features=app'], + ['cocos-editor-execute'], + ), + ['--features=cocos-editor-execute', '--', '--features=app'], + ); +}); diff --git a/apps/ai-game-creator-shell/scripts/check-config.mjs b/apps/ai-game-creator-shell/scripts/check-config.mjs index 91e3a982c..efa6f62be 100644 --- a/apps/ai-game-creator-shell/scripts/check-config.mjs +++ b/apps/ai-game-creator-shell/scripts/check-config.mjs @@ -118,6 +118,16 @@ const allowedUncalledTauriCommands = [ 'stop_local_game_preview_if_matches', 'start_game_creator_external_mcp', 'stop_game_creator_external_mcp', + 'list_agc_plugins', + 'list_agc_extensions', + 'refresh_agc_plugins', + 'start_agc_plugin', + 'stop_agc_plugin', + 'reload_agc_plugin', + 'call_agc_plugin', + 'read_agc_plugin_panel', + 'set_agc_plugin_project_path', + 'set_agc_plugin_enabled', ]; const sourceExtensions = new Set([ '.json', @@ -1289,7 +1299,7 @@ if (tauriConfig.identifier !== 'world.genarrative.ai-game-creator') { const expectedBundledDesignAgentResources = { 'design-agent': 'design-agent', }; -const expectedBundledCodexResources = { +const expectedBundledWindowsResources = { 'resources/codex/win-x64/bin/codex.exe': 'codex/win-x64/bin/codex.exe', 'resources/codex/win-x64/bin/codex-code-mode-host.exe': 'codex/win-x64/bin/codex-code-mode-host.exe', @@ -1303,6 +1313,7 @@ const expectedBundledCodexResources = { 'codex/win-x64/codex-package.json', 'resources/codex/win-x64/NOTICE.md': 'codex/win-x64/NOTICE.md', 'resources/codex/win-x64/manifest.json': 'codex/win-x64/manifest.json', + 'resources/plugins': 'plugins', }; assert.deepEqual( tauriConfig.bundle?.resources, @@ -1318,8 +1329,8 @@ for (const key of Object.keys(tauriConfig.bundle?.resources ?? {})) { } assert.deepEqual( windowsTauriConfig.bundle?.resources, - expectedBundledCodexResources, - 'AI game creator shell Windows Tauri config must bundle the complete pinned Codex resource set', + expectedBundledWindowsResources, + 'AI game creator shell Windows Tauri config must bundle the complete pinned Codex resource set and Cocos bridge payload directory', ); if ( Object.prototype.hasOwnProperty.call( diff --git a/apps/ai-game-creator-shell/scripts/start-dev-stack.mjs b/apps/ai-game-creator-shell/scripts/start-dev-stack.mjs index 8435bbfa9..9c7e9ee8d 100644 --- a/apps/ai-game-creator-shell/scripts/start-dev-stack.mjs +++ b/apps/ai-game-creator-shell/scripts/start-dev-stack.mjs @@ -436,6 +436,10 @@ function spawnChild(command, args, options, spawnImpl = spawn) { const child = spawnImpl(command, args, { ...options, shell: useShell, + // npm.cmd and the Windows shell otherwise create a visible console for + // every service in the dev stack. Their stdout/stderr is already inherited + // by the launcher, so no separate terminal window is useful. + windowsHide: process.platform === 'win32' ? true : options.windowsHide, // POSIX 下让每个长驻服务拥有独立进程组，退出时可以连同 npm、 // Node、Cargo 及其子进程一起清理，避免残留订阅任务持续刷日志。 detached: isPosix, diff --git a/apps/ai-game-creator-shell/scripts/start-tauri-dev.mjs b/apps/ai-game-creator-shell/scripts/start-tauri-dev.mjs index 4f734f7fe..0ce7e6a2b 100644 --- a/apps/ai-game-creator-shell/scripts/start-tauri-dev.mjs +++ b/apps/ai-game-creator-shell/scripts/start-tauri-dev.mjs @@ -1,6 +1,7 @@ import { resolve } from 'node:path'; import { fileURLToPath } from 'node:url'; +import { withDefaultCargoFeatures } from './cargo-features.mjs'; import { readAgcDevEndpoint, resolveAgcDevEndpoint, @@ -47,6 +48,24 @@ function buildTauriArguments(argv, devUrl = readAgcDevEndpoint().url) { ]; } +// `agc_cocos_execute` 与 Cocos 编辑器适配器只在 `cocos-editor-execute` feature 下 +// 注册。开发构建默认在 Windows 打开它，否则 Agent 的工具清单里根本没有该工具， +// 只能退化成改写脚本。可用 AGC_DEV_CARGO_FEATURES（逗号分隔）覆盖，传空串即关闭。 +function readDevCargoFeatures(env = process.env) { + const override = env.AGC_DEV_CARGO_FEATURES; + if (override !== undefined) { + return override + .split(',') + .map((value) => value.trim()) + .filter(Boolean); + } + return process.platform === 'win32' ? ['cocos-editor-execute'] : []; +} + +function withDevCargoFeatures(argv, features = readDevCargoFeatures()) { + return withDefaultCargoFeatures(argv, features); +} + function spawnTauriCli(argv, { env = process.env } = {}) { return spawnChild(process.execPath, [tauriCliPath, ...argv], { cwd: appRoot, @@ -110,7 +129,10 @@ async function runTauriDev( shutdownRequested.then(() => false), ]); if (!prepared || shutdownSignal) return 1; - const tauriArguments = buildTauriArguments(argv, endpoint.url); + const tauriArguments = buildTauriArguments( + withDevCargoFeatures(argv), + endpoint.url, + ); child = spawnCli(tauriArguments, { env: { ...withAgcDevEndpointEnv(endpoint), @@ -207,6 +229,7 @@ export { isDirectModuleExecution, runTauriDev, spawnTauriCli, + withDevCargoFeatures, }; if (isDirectModuleExecution()) { diff --git a/apps/ai-game-creator-shell/src-tauri/.taurignore b/apps/ai-game-creator-shell/src-tauri/.taurignore new file mode 100644 index 000000000..8ec126556 --- /dev/null +++ b/apps/ai-game-creator-shell/src-tauri/.taurignore @@ -0,0 +1,4 @@ +# resources/plugins 由 build.rs 从 plugins/ 复制生成，属于构建产物。 +# 它在 dev 监听范围内，重新生成会让 Tauri dev 误判为源码改动而触发 +# “构建 -> 监听 -> 再构建”的自触发循环。 +resources/plugins/ diff --git a/apps/ai-game-creator-shell/src-tauri/Cargo.lock b/apps/ai-game-creator-shell/src-tauri/Cargo.lock index f4ca27d53..d6046baf7 100644 --- a/apps/ai-game-creator-shell/src-tauri/Cargo.lock +++ b/apps/ai-game-creator-shell/src-tauri/Cargo.lock @@ -733,6 +733,20 @@ dependencies = [ "error-code", ] +[[package]] +name = "cocos-editor-bridge" +version = "0.1.0" +dependencies = [ + "cc", + "editor-adapter-api", + "reqwest 0.12.28", + "serde", + "serde_json", + "sha2", + "tungstenite", + "windows-sys 0.61.2", +] + [[package]] name = "combine" version = "4.6.7" @@ -1205,6 +1219,14 @@ version = "1.0.20" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555" +[[package]] +name = "editor-adapter-api" +version = "0.1.0" +dependencies = [ + "serde", + "serde_json", +] + [[package]] name = "either" version = "1.16.0" @@ -1709,6 +1731,8 @@ dependencies = [ "axum", "base64 0.22.1", "chromiumoxide", + "cocos-editor-bridge", + "editor-adapter-api", "futures", "getrandom 0.3.4", "http", @@ -4281,6 +4305,7 @@ dependencies = [ "cookie", "cookie_store", "encoding_rs", + "futures-channel", "futures-core", "futures-util", "h2", diff --git a/apps/ai-game-creator-shell/src-tauri/Cargo.toml b/apps/ai-game-creator-shell/src-tauri/Cargo.toml index b1b08062c..b70c07f0d 100644 --- a/apps/ai-game-creator-shell/src-tauri/Cargo.toml +++ b/apps/ai-game-creator-shell/src-tauri/Cargo.toml @@ -6,6 +6,9 @@ publish = false [features] default = [] +cocos-editor = ["cocos-editor-bridge/process-discovery"] +cocos-editor-execute = ["cocos-editor", "cocos-editor-bridge/windows-bootstrap"] +cocos-editor-injection = ["cocos-editor-execute", "cocos-editor-bridge/windows-injection"] [build-dependencies] serde = { version = "1", features = ["derive"] } @@ -19,6 +22,8 @@ ts-rs = "12.0.1" typed_floats = { version = "1.0.7", features = ["serde"] } nalgebra = { version = "0.35.0", features = ["serde-serialize"] } agent-runtime-core = { path = "../../../server-rs/crates/agent-runtime-core" } +cocos-editor-bridge = { path = "../../../plugins/agc-cocos-editor/native/cocos-editor-bridge", default-features = false } +editor-adapter-api = { path = "../../../server-rs/crates/editor-adapter-api" } base64 = "0.22" axum = "0.8" chromiumoxide = "0.9.1" diff --git a/apps/ai-game-creator-shell/src-tauri/build.rs b/apps/ai-game-creator-shell/src-tauri/build.rs index d63faf051..e9f6642e0 100644 --- a/apps/ai-game-creator-shell/src-tauri/build.rs +++ b/apps/ai-game-creator-shell/src-tauri/build.rs @@ -182,6 +182,8 @@ fn main() { ); let manifest_path = manifest_dir.join("prompts/runtime/manifest.json"); stage_bundled_codex_cli(&manifest_dir); + stage_plugin_workspace(&manifest_dir); + stage_cocos_editor_payload(&manifest_dir); let compiled = runtime_prompt_bundle::compile_manifest(&manifest_path) .unwrap_or_else(|error| panic!("Prompt Bundle 编译失败：{error}")); validate_seed_task_catalog(&compiled); @@ -203,3 +205,146 @@ fn main() { } tauri_build::build() } + +#[cfg(windows)] +fn stage_cocos_editor_payload(manifest_dir: &std::path::Path) { + if std::env::var_os("CARGO_FEATURE_COCOS_EDITOR_INJECTION").is_none() { + return; + } + let out_dir = std::path::PathBuf::from(std::env::var_os("OUT_DIR").expect("OUT_DIR")); + let profile_dir = out_dir + .ancestors() + .find(|path| path.file_name().is_some_and(|name| name == "build")) + .and_then(|build_dir| build_dir.parent()) + .expect("AGC Cargo profile directory not found"); + let candidates = [ + profile_dir.join("deps/cocos_editor_bridge.dll"), + profile_dir.join("cocos_editor_bridge.dll"), + ]; + let source = candidates + .iter() + .find(|path| path.is_file()) + .unwrap_or_else(|| { + panic!( + "Cocos bridge native payload 未构建：{}", + candidates + .iter() + .map(|p| p.display().to_string()) + .collect::>() + .join("；") + ) + }); + for destination in [ + // 插件工作区里的 payload 是开发态与打包态的唯一真源。 + manifest_dir + .join("../../../plugins/agc-cocos-editor/native/payload/cocos-editor-bridge.dll"), + // 随包资源目录与 tauri.windows.conf.json 的 `resources/plugins` 映射保持一致。 + manifest_dir + .join("resources/plugins/agc-cocos-editor/native/payload/cocos-editor-bridge.dll"), + ] { + std::fs::create_dir_all(destination.parent().expect("payload resource parent")) + .expect("创建 Cocos bridge payload 目录失败"); + std::fs::copy(source, &destination).expect("复制 Cocos bridge native payload 失败"); + } + println!("cargo:rerun-if-changed={}", source.display()); +} + +#[cfg(not(windows))] +fn stage_cocos_editor_payload(_manifest_dir: &std::path::Path) {} + +/// 把 `plugins/` 工作区里的插件包随包映射到应用资源目录。 +/// +/// 只复制插件运行需要的清单、入口、面板和 native payload，不复制 native 源码、 +/// Cargo target 目录或 node_modules。 +#[cfg(windows)] +fn stage_plugin_workspace(manifest_dir: &std::path::Path) { + let repo_root = manifest_dir + .parent() + .and_then(|app_root| app_root.parent()) + .and_then(|apps_dir| apps_dir.parent()) + .expect("AGC 应用必须位于仓库 apps 目录下") + .to_path_buf(); + let workspace = repo_root.join("plugins"); + let destination_root = manifest_dir.join("resources/plugins"); + std::fs::create_dir_all(&destination_root).expect("创建插件资源目录失败"); + let entries = match std::fs::read_dir(&workspace) { + Ok(entries) => entries, + Err(_) => return, + }; + for entry in entries.flatten() { + let plugin_root = entry.path(); + if !plugin_root.is_dir() || !plugin_root.join("plugin.json").is_file() { + continue; + } + let name = entry.file_name(); + let destination = destination_root.join(&name); + copy_plugin_file( + &plugin_root.join("plugin.json"), + &destination.join("plugin.json"), + ); + for relative in [ + std::path::PathBuf::from("src"), + std::path::PathBuf::from("panels"), + std::path::PathBuf::from("native/payload"), + ] { + copy_plugin_tree(&plugin_root.join(&relative), &destination.join(&relative)); + } + println!("cargo:rerun-if-changed={}", plugin_root.display()); + } +} + +#[cfg(windows)] +fn stage_plugin_file(source: &std::path::Path, destination: &std::path::Path) { + let Ok(bytes) = std::fs::read(source) else { + return; + }; + if std::fs::read(destination).is_ok_and(|existing| existing == bytes) { + return; + } + if let Some(parent) = destination.parent() { + std::fs::create_dir_all(parent).expect("创建插件资源目录失败"); + } + std::fs::write(destination, bytes).expect("复制插件资源失败"); +} + +#[cfg(windows)] +fn copy_plugin_tree(source: &std::path::Path, destination: &std::path::Path) { + let entries = match std::fs::read_dir(source) { + Ok(entries) => entries, + Err(_) => return, + }; + for entry in entries.flatten() { + let target = destination.join(entry.file_name()); + let path = entry.path(); + if path.is_dir() { + let name = entry.file_name(); + let name = name.to_string_lossy(); + if matches!(name.as_ref(), "target" | "node_modules" | ".git") { + continue; + } + std::fs::create_dir_all(&target).expect("创建插件资源目录失败"); + copy_plugin_tree(&path, &target); + } else { + // 测试文件不随包分发。 + let name = entry.file_name(); + let name = name.to_string_lossy(); + if name.contains(".test.") { + continue; + } + stage_plugin_file(&path, &target); + } + } +} + +#[cfg(windows)] +fn copy_plugin_file(source: &std::path::Path, destination: &std::path::Path) { + if !source.is_file() { + return; + } + std::fs::create_dir_all(destination.parent().expect("插件资源父目录")) + .expect("创建插件资源目录失败"); + std::fs::copy(source, destination).expect("复制插件资源失败"); +} + +#[cfg(not(windows))] +fn stage_plugin_workspace(_manifest_dir: &std::path::Path) {} diff --git a/apps/ai-game-creator-shell/src-tauri/resources/cocos-editor-bridge/.gitignore b/apps/ai-game-creator-shell/src-tauri/resources/cocos-editor-bridge/.gitignore new file mode 100644 index 000000000..6a7461313 --- /dev/null +++ b/apps/ai-game-creator-shell/src-tauri/resources/cocos-editor-bridge/.gitignore @@ -0,0 +1 @@ +*.dll diff --git a/apps/ai-game-creator-shell/src-tauri/resources/cocos-editor-bridge/.gitkeep b/apps/ai-game-creator-shell/src-tauri/resources/cocos-editor-bridge/.gitkeep new file mode 100644 index 000000000..e69de29bb diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs index 2088c1c08..d93dbe06b 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/codex_app_server.rs @@ -305,6 +305,35 @@ fn game_creator_codex_app_server_error_detail_indicates_auth_failure( || detail.contains("http 403") } +fn game_creator_codex_app_server_error_detail(error: &serde_json::Value) -> String { + let Some(error) = error.as_object() else { + return String::new(); + }; + ["message", "additionalDetails", "code"] + .into_iter() + .filter_map(|field| error.get(field).and_then(serde_json::Value::as_str)) + .collect::>() + .join(" ") + .to_ascii_lowercase() +} + +fn game_creator_codex_app_server_error_detail_indicates_stream_requirement( + error: &serde_json::Value, +) -> bool { + let detail = game_creator_codex_app_server_error_detail(error); + detail.contains("stream must be set to true") + || detail.contains("stream=true") + || detail.contains("stream is required") +} + +fn game_creator_codex_app_server_error_detail_indicates_timeout(error: &serde_json::Value) -> bool { + let detail = game_creator_codex_app_server_error_detail(error); + detail.contains("timed out") + || detail.contains("timeout") + || detail.contains("request deadline exceeded") + || detail.contains("deadline exceeded") +} + fn game_creator_codex_app_server_error_detail_indicates_request_too_large( error: &serde_json::Value, ) -> bool { @@ -362,6 +391,15 @@ fn game_creator_codex_app_server_failed_turn_error( if game_creator_codex_app_server_error_detail_indicates_request_too_large(error) { return game_creator_codex_app_server_error_kind("request-too-large"); } + if game_creator_codex_app_server_error_detail_indicates_stream_requirement(error) { + return game_creator_codex_app_server_error_kind("stream-required"); + } + if game_creator_codex_app_server_error_detail_indicates_timeout(error) { + return platform_llm::LlmError::Connectivity { + attempts: 1, + message: "Codex app-server 上游请求超时".to_string(), + }; + } if game_creator_codex_app_server_error_detail_indicates_auth_failure(error) { return game_creator_codex_app_server_error_kind("unauthorized"); } @@ -1070,6 +1108,7 @@ fn game_creator_codex_app_server_pool_key( "skillPackIdentity": skill_pack_identity, "clientSkillIdentity": client_skill_identity, "clientMcpIdentity": client_mcp_identity, + "builtinPluginTools": crate::builtin_plugins::available_agent_tools(), "controlledWebSearch": llm.web_search_enabled, "directToolBridgeProtocol": if workspace_mode == CodexAppServerWorkspaceMode::DirectProject { DIRECT_TOOL_BRIDGE_PROTOCOL } else { "disabled" }, "providerProxyProtocol": if workspace_mode == CodexAppServerWorkspaceMode::DirectProject { CODEX_PROVIDER_PROXY_PROTOCOL } else { "disabled" }, @@ -2463,10 +2502,12 @@ impl CodexAppServerConnection { // Codex's default provider in Debug builds. self.inner._provider_proxy.is_some() || !llm.api_key.trim().is_empty(), ); - let result = self - .request("thread/start", params) - .await - .map_err(platform_llm::LlmError::Transport)?; + let result = match self.request("thread/start", params).await { + Ok(result) => result, + Err(error) => { + return Err(platform_llm::LlmError::Transport(error)); + } + }; let thread_id = result .pointer("/thread/id") .and_then(serde_json::Value::as_str) @@ -4810,6 +4851,37 @@ mod tests { } } + #[test] + fn codex_app_server_failed_turn_maps_stream_and_timeout_details() { + let stream_error = game_creator_codex_app_server_failed_turn_error(&serde_json::json!({ + "status": "failed", + "error": { + "message": "Stream must be set to true", + "codexErrorInfo": "other" + } + })); + assert_eq!( + stream_error, + platform_llm::LlmError::InvalidRequest( + "codex-app-server-error:stream-required".to_string() + ) + ); + let timeout_error = game_creator_codex_app_server_failed_turn_error(&serde_json::json!({ + "status": "failed", + "error": { + "message": "provider request timed out", + "codexErrorInfo": "other" + } + })); + assert_eq!( + timeout_error, + platform_llm::LlmError::Connectivity { + attempts: 1, + message: "Codex app-server 上游请求超时".to_string() + } + ); + } + #[test] fn codex_app_server_failed_turn_maps_insufficient_mud_points_to_stable_upstream_error() { for detail in [ @@ -5051,6 +5123,42 @@ while IFS= read -r line; do :; done assert_ne!(disabled, enabled); } + #[cfg(feature = "cocos-editor-execute")] + #[test] + fn codex_app_server_pool_key_tracks_builtin_plugin_switch() { + let _guard = crate::builtin_plugins::test_lock(); + let config = tempfile::tempdir().unwrap(); + crate::builtin_plugins::initialize(config.path()).unwrap(); + let key = || { + game_creator_codex_app_server_pool_key( + &test_llm(), + "codex-cli 0.147.0", + &test_snapshot(), + "credential", + CodexAppServerWorkspaceMode::DirectProject, + ) + }; + crate::builtin_plugins::set_enabled( + crate::builtin_plugins::AGC_COCOS_EDITOR_PLUGIN_ID, + false, + ) + .unwrap(); + let disabled = key(); + crate::builtin_plugins::set_enabled( + crate::builtin_plugins::AGC_COCOS_EDITOR_PLUGIN_ID, + true, + ) + .unwrap(); + let enabled = key(); + assert_ne!(disabled, enabled); + crate::builtin_plugins::set_enabled( + crate::builtin_plugins::AGC_COCOS_EDITOR_PLUGIN_ID, + false, + ) + .unwrap(); + assert_eq!(disabled, key()); + } + #[test] fn direct_file_change_approval_is_limited_to_workspace() { let temp = tempfile::tempdir().expect("temp dir"); diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_project_history.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_project_history.rs index 42777dcfa..86021122c 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_project_history.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_project_history.rs @@ -1,3 +1,4 @@ +use super::runtime_actions::acquire_game_creator_agent_runtime_project_write_lock_with_wait; use crate::config::prepare_game_creator_private_path_for_read; use crate::project::{ append_jsonl_line_unlocked, enforce_project_permission_policy, project_append_lock_for, @@ -204,7 +205,15 @@ fn append_direct_project_history_item_at_with_user_policy( if !allow_user_item && is_direct_project_codex_user_item(item) { return Ok(()); } - let _project_lock = crate::project::acquire_project_write_lock(root, "conversation.write")?; + // DirectProject 历史与 `agc_write_file` 共用项目写锁。文件写入在锁内要跑 Windows + // 私有路径准备与原子替换，现场实测一次 2.6KB 写入占锁 5.5 秒；零等待取锁会让 + // 流式历史落盘在写文件期间直接失败，并把整轮判成“项目正在被其他写操作占用” + // （持锁方 commandId=direct-codex.file.write、ownerIsSelf=true）。这里与其它写入口 + // 保持同一档有界等待；主路径已在阻塞线程池中执行。 + let _project_lock = acquire_game_creator_agent_runtime_project_write_lock_with_wait( + root, + "conversation.write", + )?; let path = history_path(root); let history_exists = prepare_game_creator_private_path_for_read(&path, false, "DirectProject 历史")?; @@ -429,6 +438,50 @@ mod tests { assert_eq!(items, vec![item]); } + #[test] + fn append_waits_for_a_same_process_project_writer() { + // 用 canonical 临时根：Windows 上 `%TEMP%` 的 8.3 短路径会让私有路径所有者 + // 校验把测试目录判成“不属于当前用户”。 + let temp_root = std::env::temp_dir() + .canonicalize() + .unwrap_or_else(|_| std::env::temp_dir()); + let root = temp_root.join(format!( + "genarrative-agc-history-wait-{}-{}", + std::process::id(), + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|value| value.as_millis()) + .unwrap_or_default() + )); + std::fs::create_dir_all(&root).expect("create project root"); + crate::init_local_game_project_at(&root, "history-wait", "历史等待").expect("init project"); + // 模拟 `agc_write_file`：它持锁期间历史落盘必须排队等待，而不是零等待失败后 + // 把整轮判成“项目正在被其他写操作占用”。 + let holder = crate::project::acquire_project_write_lock(&root, "direct-codex.file.write") + .expect("hold project write lock"); + let worker_root = root.clone(); + let worker = std::thread::spawn(move || { + append_direct_project_history_item_at( + &worker_root, + &serde_json::json!({ + "type": "message", + "role": "assistant", + "id": "waits-for-writer", + "content": [{"type": "output_text", "text": "排队等待"}] + }), + ) + }); + std::thread::sleep(std::time::Duration::from_millis(300)); + drop(holder); + worker + .join() + .expect("append worker") + .expect("history append must wait for the writer"); + let items = read_direct_project_history_items_at(&root).expect("read history"); + assert_eq!(items.len(), 1); + let _ = std::fs::remove_dir_all(&root); + } + #[test] fn codex_user_echo_is_filtered_but_agc_user_message_is_persisted() { let root = tempfile::tempdir().expect("temp project"); diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs index 2d94613ed..49f43bacc 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_runtime.rs @@ -10,7 +10,9 @@ const MAX_DIRECT_SYSTEM_PROMPT_CHARS: usize = 16 * 1024; const MIN_DIRECT_CLIENT_TURN_ID_CHARS: usize = 6; const MAX_DIRECT_CLIENT_TURN_ID_CHARS: usize = 160; const DIRECT_TAONIER_IDENTITY_GUIDANCE: &str = "对外身份合同：你是“陶泥儿”，是 Genarrative 的游戏创作助手。用户询问你是谁、你的名称或能力时，以陶泥儿的身份回答；不要把 Codex、ChatGPT、OpenAI、模型、通用 AI 助手或内部执行智能体当作自己的名称或对外身份。Codex app-server 仅是客户端内部执行技术；只有用户明确询问底层实现时才可如实说明，同时仍以陶泥儿自称。"; -const DIRECT_AGC_ENGINEERING_GUIDANCE: &str = "AGC 工程合同：当前 cwd 是用户选择的项目目录。新 Web 游戏使用 npm + Vite，Phaser 固定为 4.2.1，在 `game.js` 或模块中使用 `import Phaser from 'phaser'`；可以按需使用其它 npm 依赖，不得复制 Phaser bundle、使用 import map 或 CDN。先读取当前 cwd 下适用的 AGENTS.md、README 或项目说明。源码使用 cwd 相对路径，例如 `index.html`、`style.css`、`game.js`、`package.json`、`package-lock.json`、`assets/hero.png`；依赖安装与构建使用项目自己的 npm scripts，完成后必须从 `dist/index.html` 试玩。 原生文件工具、patch 和命令参数使用 cwd 相对路径，例如 `index.html`、`style.css`、`game.js`、`assets/hero.png`；如果 Codex 原生文件修改不可用，可以按需用客户端 `agc_write_file` 把文本写入项目相对路径。调用 `agc_write_file` 时，content 必须是目标文件的完整原始 UTF-8 正文；不得把 command.exec 的 Exit code、Wall time、Output 包装、终端日志或解释文字一起复制进 content，命令结果只能用于判断，不能当作文件正文。`../`、绝对路径、`.agent/`、`.git/`、密钥文件和 Runtime 控制面属于客户端边界，不能请求扩权或直接改写。DirectProject 提供 Codex 原生文件、搜索、命令、图片查看、Skill、经客户端注入的 `agc_tools` MCP，以及客户端扩展列表中用户已启用的第三方 MCP。用户明确指定第三方 MCP Server 或工具时，先在当前可用工具中查找并直接调用；找不到时如实说明，不得伪造。你可以按需选择这些能力：`agc_write_file` 写入代码、配置、资源依赖清单或说明文件；`agc_generate_image` 生成普通图片、角色图、视觉规范图（icon-spec）、UI 设计图或发布宣传图；`agc_edit_image` 修改已登记图片；`taonier_prepare_game_art` 准备完整游戏美术包及可用的 canonical 切片；`agc_list_registered_assets`、`agc_list_project_files`、`agc_list_account_assets`、`agc_import_account_assets` 用于发现和接入资源依赖；`agc_create_or_derive_resource` 用于视频、角色动画、音效或背景音乐；`agc_browser_playtest` 用于需要时的本地试玩观察；Skill references 按需使用相对路径直接读取。切图、资源依赖、规范图和试玩都只是可选工具提示，不要求调用、固定顺序或特定产物，AGC 不会据此替你拆任务、编排 DAG、做强验收或阻止继续执行；不要等待 Supervisor、harness 或宿主规划器。不要读取或输出凭据、Token、Cookie、auth.json、.env 或宿主私密路径；项目锁、付费提交、幂等键、下载校验和客户端投影由客户端处理。游戏文件真实变化后客户端可登记资源和版本，Codex 不直接保存或伪造项目版本。"; +const DIRECT_AGC_ENGINEERING_GUIDANCE: &str = "AGC 工程合同：当前 cwd 是用户选择的项目目录。先读取当前 cwd 下适用的 AGENTS.md、README 或项目说明并识别实际引擎与工程结构。用户明确指定 Cocos、Unity、Godot 或其它编辑器/引擎，而当前目录不具备对应工程结构时，必须先说明不匹配并提出澄清；在澄清前不得把请求改写成 Phaser/Web 实现，也不得写文件、安装依赖、构建或试玩。仅当用户确认继续当前工程或提供了匹配的项目目录后才执行。识别为 Cocos Creator 项目时，优先使用 `agc_cocos_execute` 或 Cocos 插件的 `cocos.editor.execute` 在已打开的 Creator 编辑器中操作；不要创建 Phaser 文件，不要把 Cocos 请求改写成 Web 工程。新 Web 游戏使用 npm + Vite，Phaser 固定为 4.2.1，在 `game.js` 或模块中使用 `import Phaser from 'phaser'`；可以按需使用其它 npm 依赖，不得复制 Phaser bundle、使用 import map 或 CDN。简单修改只完成用户明确要求的范围；安装依赖、构建和试玩是后续操作，除非用户明确要求或它们是完成该项不可替代的最小验证，否则不得擅自扩展任务。源码使用 cwd 相对路径，例如 `index.html`、`style.css`、`game.js`、`package.json`、`package-lock.json`、`assets/hero.png`；依赖安装与构建使用项目自己的 npm scripts。原生文件工具、patch 和命令参数使用 cwd 相对路径，例如 `index.html`、`style.css`、`game.js`、`assets/hero.png`；如果 Codex 原生文件修改不可用，可以按需用客户端 `agc_write_file` 把文本写入项目相对路径。调用 `agc_write_file` 时，content 必须是目标文件的完整原始 UTF-8 正文；不得把 command.exec 的 Exit code、Wall time、Output 包装、终端日志或解释文字一起复制进 content，命令结果只能用于判断，不能当作文件正文。`../`、绝对路径、`.agent/`、`.git/`、密钥文件和 Runtime 控制面属于客户端边界，不能请求扩权或直接改写。DirectProject 提供 Codex 原生文件、搜索、命令、图片查看、Skill、经客户端注入的 `agc_tools` MCP，以及客户端扩展列表中用户已启用的第三方 MCP。用户明确指定第三方 MCP Server 或工具时，先在当前可用工具中查找并直接调用；找不到时如实说明，不得伪造。你可以按需选择这些能力：`agc_write_file` 写入代码、配置、资源依赖清单或说明文件；`agc_generate_image` 生成普通图片、角色图、视觉规范图（icon-spec）、UI 设计图；`agc_edit_image` 修改已登记图片；`taonier_prepare_game_art` 准备完整游戏美术包及可用的 canonical 切片；`agc_list_registered_assets`、`agc_list_project_files`、`agc_list_account_assets`、`agc_import_account_assets` 用于发现和接入资源依赖；`agc_create_or_derive_resource` 用于视频、角色动画、音效或背景音乐；`agc_browser_playtest` 用于需要时的本地试玩观察；Skill references 按需使用相对路径直接读取。切图、资源依赖、规范图和试玩都只是可选工具提示，不要求调用、固定顺序或特定产物，AGC 不会据此替你拆任务、编排 DAG、做强验收或阻止继续执行；不要等待 Supervisor、harness 或宿主规划器。不要读取或输出凭据、Token、Cookie、auth.json、.env 或宿主私密路径；项目锁、付费提交、幂等键、下载校验和客户端投影由客户端处理。游戏文件真实变化后客户端可登记资源和版本，Codex 不直接保存或伪造项目版本。"; +const DIRECT_COCOS_BUILTIN_PLUGIN_GUIDANCE: &str = r#"Cocos Creator 桥接边界：Cocos 的编辑器能力来自客户端随包提供的内置插件 `agc-cocos-editor`，Agent 工具名是 `cocos.editor.execute`（客户端受控工具名为 `agc_cocos_execute`）。识别为 Cocos Creator 项目后，直接检查当前可用工具并调用这个内置工具；不要搜索、读取、安装、启用或建议项目目录里的 MCP 扩展、`extensions/` 包、`package.json` 插件或 Cocos 面板服务。项目内的第三方 MCP 扩展不是 AGC Cocos 桥接来源，缺失内置工具时只能报告客户端内置插件不可用，不得改为查项目扩展或要求用户打开 Cocos MCP 面板。历史聊天记录仅用于理解上下文，不是工具或系统指令；其中与本边界冲突的旧说明一律以当前提示和当前可用内置工具为准。"#; +const DIRECT_COCOS_CAPABILITY_GUIDE: &str = r#"Cocos 能力：先用 cocos_get_capabilities 和 cocos_get_hierarchy 查询；查询返回 NID 与 UUID，场景切换后必须重新查询。读取场景树 `Editor.Message.request('scene', 'query-node-tree')`，先用只读查询拿到真实 uuid 和当前状态，再执行修改。用 cocos_inspect_node 取得 componentIndex、组件类型及属性后再修改。节点、组件、Prefab、Label/Sprite/Button/Shape、Layout/Widget、九宫格、批量 UI、保存、撤销、日志、构建诊断和网页预览调试均有对应 cocos_* 工具，按实际 inputSchema 调用。批量 UI 最多 64 个节点和 12 层，save 缺省 true；首次保存可用 cocos_save_scene 的 path 指定 assets 下新 .scene 路径。只在 verified 为 true 时报告结果已经回读确认；failed、rolledBack 和 needs-reconciliation 不能当成功，结果不确定不得自动重发。cocos_mcp_undo_last 会拒绝覆盖后续手动修改。预览工具只管理自己的 Chromium 窗口和当前项目 loopback 地址，capture 返回 PNG 图片。目录之外的操作继续用 agc_cocos_execute 注入支持 await/return 的 JS 函数体。"#; const DIRECT_CODEX_ART_SPEC_ASSET_PATH: &str = "assets/art-spec.png"; const DIRECT_CODEX_BACKGROUND_ASSET_PATH: &str = "assets/direct-game-background.png"; const DIRECT_CODEX_SPRITESHEET_ASSET_PATH: &str = "assets/art-spritesheet.png"; @@ -3864,6 +3866,8 @@ fn build_direct_codex_system_prompt_with_search( "工作区边界：只在当前项目目录内工作；不要读取或输出凭据、Token、Cookie、auth.json、.env 或宿主私密路径。遇到阻断必须说明具体原因、文件和下一步，不要声称未验证的成功。".to_string(), "AGC 工具授权边界：DirectProject 的 agc_tools 由当前客户端桥接到 AGC 后端，使用客户端已有登录会话和受控凭据完成授权。用户不需要、也不得向你提供、配置、粘贴或创建 API Key、Token、Cookie、URL 或 .env。工具返回 401/403 时，只说明 AGC 客户端登录或权限状态异常并停止，不要索要凭据、猜测外部 API，也不要暴露内部 URL。".to_string(), DIRECT_AGC_ENGINEERING_GUIDANCE.to_string(), + DIRECT_COCOS_BUILTIN_PLUGIN_GUIDANCE.to_string(), + DIRECT_COCOS_CAPABILITY_GUIDE.to_string(), "工程执行要求：优先复用现有结构；按需读取真实文件，不依赖客户端预注入源码快照；修改后运行与改动相关的本地验证。不要创建 Supervisor、专业 Agent 或平行项目。".to_string(), format!("提示词与技能：{skill_index}"), ]; @@ -4714,6 +4718,14 @@ mod tests { assert!(prompt.contains("客户端扩展列表中用户已启用的第三方 MCP")); assert!(prompt.contains("用户明确指定第三方 MCP Server 或工具时")); assert!(prompt.contains("先读取当前 cwd 下适用的 AGENTS.md、README 或项目说明")); + assert!(prompt.contains("用户明确指定 Cocos、Unity、Godot 或其它编辑器/引擎")); + assert!(prompt.contains("Cocos 的编辑器能力来自客户端随包提供的内置插件")); + assert!(prompt.contains("不要搜索、读取、安装、启用或建议项目目录里的 MCP 扩展")); + assert!(prompt.contains("不得改为查项目扩展或要求用户打开 Cocos MCP 面板")); + assert!(prompt.contains("读取场景树 `Editor.Message.request('scene', 'query-node-tree')`")); + assert!(prompt.contains("先用只读查询拿到真实 uuid 和当前状态")); + assert!(prompt.contains("在澄清前不得把请求改写成 Phaser/Web 实现")); + assert!(prompt.contains("简单修改只完成用户明确要求的范围")); assert!(prompt.contains("agc_write_file")); assert!(prompt.contains("content 必须是目标文件的完整原始 UTF-8 正文")); assert!(prompt.contains("不得把 command.exec 的 Exit code、Wall time、Output 包装")); diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tool_bridge.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tool_bridge.rs index 260c1a90f..172c5c674 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tool_bridge.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tool_bridge.rs @@ -54,6 +54,8 @@ struct DirectToolBridgeState { regeneration_gate: tokio::sync::Mutex<()>, resource_generation_gate: tokio::sync::Mutex<()>, image_generation_gate: tokio::sync::Mutex<()>, + #[cfg(all(windows, feature = "cocos-editor-execute"))] + cocos_execute_uncertain: tokio::sync::Mutex, } #[derive(Default)] @@ -687,6 +689,8 @@ fn direct_tool_bridge_state_with_search( regeneration_gate: tokio::sync::Mutex::new(()), resource_generation_gate: tokio::sync::Mutex::new(()), image_generation_gate: tokio::sync::Mutex::new(()), + #[cfg(all(windows, feature = "cocos-editor-execute"))] + cocos_execute_uncertain: tokio::sync::Mutex::new(false), }) } @@ -1475,12 +1479,28 @@ fn bridge_write_file(root: &Path, arguments: &Value) -> Value { reject_command_output_wrapper(content)?; // 这是用户直接触发、失败即整轮无法落盘的项目写入通道： // 短暂重叠排队等成功，只有预算耗尽才报出带持锁方身份的错误。 + let acquire_started = std::time::Instant::now(); let _lock = acquire_game_creator_agent_runtime_project_write_lock_with_wait( root, "direct-codex.file.write", )?; + let lock_wait_ms = acquire_started.elapsed().as_millis(); + let write_started = std::time::Instant::now(); let written = write_local_project_file_at(root, &path, content)?; + let write_ms = write_started.elapsed().as_millis(); + let revision_started = std::time::Instant::now(); let revision = advance_agent_runtime_project_revision_locked(root)?; + // 现场一次 2.6KB 写入实测 5.5 秒。只在明显偏慢时记账，正常写入不刷日志。 + if lock_wait_ms + write_ms > 200 { + app_log!( + "direct.file.write.timing path={} bytes={} lockWaitMs={} writeMs={} revisionMs={}", + written.path, + content.len(), + lock_wait_ms, + write_ms, + revision_started.elapsed().as_millis() + ); + } Ok::<_, String>(json!({ "status": "completed", "path": written.path, @@ -2318,11 +2338,193 @@ async fn bridge_web_search_at(root: &Path, arguments: &Value, search_url: &str) } } +#[cfg(all(windows, feature = "cocos-editor-execute"))] +async fn bridge_cocos_execute(state: &DirectToolBridgeState, arguments: &Value) -> Value { + bridge_cocos_call(state, arguments, None).await +} + +#[cfg(all(windows, feature = "cocos-editor-execute"))] +async fn bridge_cocos_call( + state: &DirectToolBridgeState, + arguments: &Value, + operation: Option<&str>, +) -> Value { + if !crate::builtin_plugins::cocos_editor_agent_tool_available() { + return bridge_tool_result( + "Cocos Creator 插件已禁用，agc_cocos_execute 不可用".to_string(), + Vec::new(), + true, + ); + } + let prepared = (|| { + enforce_project_permission_policy(&state.root, "cocos.editor.execute")?; + if let Some(operation) = operation { + let tool = cocos_editor_bridge::cocos_operation_catalog() + .iter() + .find(|tool| tool["name"] == operation) + .ok_or_else(|| "未知 Cocos 操作".to_string())?; + let validator = jsonschema::validator_for(&tool["inputSchema"]) + .map_err(|e| format!("Cocos schema 错误：{e}"))?; + if let Err(error) = validator.validate(arguments) { + return Err(format!("Cocos 参数无效：{error}")); + } + return cocos_editor_bridge::build_cocos_operation_code(operation, arguments) + .map_err(|e| e.to_string()); + } + bridge_reject_unknown_fields(arguments, &["code"])?; + let code = arguments + .get("code") + .and_then(Value::as_str) + .ok_or_else(|| "code 必须是 JavaScript 函数体".to_string())?; + cocos_editor_bridge::validate_execute_code(code).map_err(|error| error.to_string())?; + Ok::<_, String>(code.to_string()) + })(); + let code = match prepared { + Ok(code) => code, + Err(error) => { + return bridge_tool_result( + redact_agent_runtime_error(&state.root, &error, 480), + Vec::new(), + true, + ) + } + }; + let Ok(mut uncertain) = state.cocos_execute_uncertain.try_lock() else { + return bridge_tool_result( + json!({"status":"failed","retryAllowed":false,"message":"已有 Cocos 操作执行中，请等待回执"}).to_string(), + Vec::new(), true); + }; + if *uncertain { + return bridge_tool_result( + json!({ + "status": "needs-reconciliation", "retryAllowed": false, + "message": "先前 Cocos execute 结果待核对，当前 bridge 不再发送执行命令" + }) + .to_string(), + Vec::new(), + true, + ); + } + let root = state.root.clone(); + let timeout_ms = if operation.is_some() { + 60_000 + } else { + cocos_editor_bridge::DEFAULT_COMMAND_TIMEOUT_MS + }; + let result = tokio::task::spawn_blocking(move || { + // Cocos execute talks to the already-open Creator process through its + // validated Inspector/pipe bridge. It does not mutate AGC's project + // files or manifest, so it must not wait on `.agent/project.lock`. + // File-writing tools keep their own project lock separately. + if !crate::builtin_plugins::cocos_editor_agent_tool_available() { + return Err(cocos_editor_bridge::BridgeError::InvalidInput( + "Cocos Creator 插件已禁用".to_string(), + )); + } + cocos_editor_bridge::execute_cocos_editor_code_for_project( + root.to_string_lossy().as_ref(), + &code, + timeout_ms, + ) + }) + .await; + match result { + Ok(Ok(response)) => { + let mut result = response.result; + let status = if operation.is_some() { + result + .as_ref() + .and_then(|v| v["status"].as_str()) + .unwrap_or(if response.ok { "completed" } else { "failed" }) + .to_string() + } else if response.ok { + "completed".to_string() + } else { + "failed".to_string() + }; + let is_error = !response.ok || status != "completed"; + if status == "needs-reconciliation" { + *uncertain = true; + } + // 截图以 MCP image block 返回，不能被文本截断破坏 base64。 + let mut images = Vec::new(); + if operation == Some("cocos_preview_debug_capture") { + if let Some(value) = result + .as_mut() + .and_then(|v| v.get_mut("result")) + .and_then(Value::as_object_mut) + { + if let Some(image) = value.remove("__image") { + if image["mimeType"] == "image/png" { + if let Some(data) = image["data"].as_str() { + images.push(data.to_string()); + } + } + } + } + } + let text = json!({ + "status": status, + "requestId": response.request_id, + "result": result, + "error": response.error, + }) + .to_string(); + bridge_tool_result( + redact_agent_runtime_project_paths( + &state.root, + &text, + if operation.is_some() { + 2 * 1024 * 1024 + } else { + 32_000 + }, + ), + images, + is_error, + ) + } + failed => { + let (is_uncertain, error) = match failed { + Ok(Err(error)) => ( + matches!( + &error, + cocos_editor_bridge::BridgeError::ExecutionUncertain(_) + ), + error.to_string(), + ), + Err(_) => ( + true, + "Cocos execute worker 退出，执行结果需要核对".to_string(), + ), + Ok(Ok(_)) => unreachable!(), + }; + *uncertain = is_uncertain; + bridge_tool_result( + json!({ + "status": if is_uncertain { "needs-reconciliation" } else { "failed" }, + "retryAllowed": !is_uncertain, + "message": redact_agent_runtime_error(&state.root, &error, 480), + }) + .to_string(), + Vec::new(), + true, + ) + } + } +} + async fn handle_direct_tool_bridge( State(state): State>, Json(request): Json, ) -> Json { let result = match request.tool.as_str() { + // 隔离 MCP 只取工具名，不接触真实 AppData 或读取权限。 + "builtin.plugins.tools" => bridge_tool_result( + json!({"tools": crate::builtin_plugins::available_agent_tools()}).to_string(), + Vec::new(), + false, + ), "taonier_prepare_game_art" => bridge_prepare_game_art(&state, &request.arguments).await, "agc_generate_image" => bridge_generate_image(&state, &request.arguments).await, "agc_edit_image" => bridge_edit_image(&state, &request.arguments).await, @@ -2330,6 +2532,12 @@ async fn handle_direct_tool_bridge( bridge_list_registered_assets(&state.root, &request.arguments) } "agc_list_project_files" => bridge_list_project_files(&state.root, &request.arguments), + #[cfg(all(windows, feature = "cocos-editor-execute"))] + "agc_cocos_execute" => bridge_cocos_execute(&state, &request.arguments).await, + #[cfg(all(windows, feature = "cocos-editor-execute"))] + operation if cocos_editor_bridge::is_cocos_operation(operation) => { + bridge_cocos_call(&state, &request.arguments, Some(operation)).await + } "agc_write_file" => { bridge_write_file_in_blocking_pool(state.root.clone(), request.arguments).await } @@ -2375,14 +2583,11 @@ pub(crate) async fn start_direct_tool_bridge( .route(&route, post(handle_direct_tool_bridge)) .layer(DefaultBodyLimit::max(DIRECT_TOOL_BRIDGE_MAX_REQUEST_BYTES)) .with_state(Arc::clone(&state)); + let url = format!("http://127.0.0.1:{}{route}", address.port()); let task = tokio::spawn(async move { let _ = axum::serve(listener, app).await; }); - Ok(DirectToolBridge { - url: format!("http://127.0.0.1:{}{route}", address.port()), - state, - task, - }) + Ok(DirectToolBridge { url, state, task }) } #[cfg(test)] diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tools_mcp.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tools_mcp.rs index 3dde7a64a..419b668e7 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tools_mcp.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/direct_tools_mcp.rs @@ -74,11 +74,36 @@ pub(crate) fn run_direct_tools_mcp_if_requested(args: &[String]) -> Option }) } -fn direct_tools_mcp_specs() -> Value { - direct_tools_mcp_specs_for(controlled_web_search_enabled()) +async fn direct_tools_mcp_specs() -> Value { + let mut cocos_editor_available = false; + if cfg!(all(windows, feature = "cocos-editor-execute")) { + // 每次 tools/list 询问绑定的宿主；失败时不广告可选插件工具。 + if let Ok(result) = tokio::time::timeout( + std::time::Duration::from_secs(5), + call_client_tool_bridge("builtin.plugins.tools", &json!({})), + ) + .await + { + if result["isError"] == false { + let availability = result + .pointer("/content/0/text") + .and_then(Value::as_str) + .and_then(|text| serde_json::from_str::(text).ok()); + cocos_editor_available = availability + .as_ref() + .and_then(|v| v["tools"].as_array()) + .is_some_and(|tools| { + tools + .iter() + .any(|tool| tool == crate::builtin_plugins::AGC_COCOS_EDITOR_TOOL_NAME) + }); + } + } + } + direct_tools_mcp_specs_for(controlled_web_search_enabled(), cocos_editor_available) } -fn direct_tools_mcp_specs_for(controlled_web_search: bool) -> Value { +fn direct_tools_mcp_specs_for(controlled_web_search: bool, _cocos_editor_available: bool) -> Value { let tools = vec![ json!({ "name": "client.session.info", @@ -431,6 +456,24 @@ fn direct_tools_mcp_specs_for(controlled_web_search: bool) -> Value { }), ]; let mut tools = tools; + #[cfg(all(windows, feature = "cocos-editor-execute"))] + if _cocos_editor_available { + tools.push(json!({ + "name": "agc_cocos_execute", + "description": "在当前项目已连接的 Cocos Creator 主进程执行 JavaScript 函数体，支持 await 和 return。宿主绑定项目和目标进程，只提交 code。结果待核对或超时后禁止自动重发；使用 Editor.Message 调用 Creator API。", + "inputSchema": { + "type": "object", + "properties": { "code": { "type": "string", "minLength": 1, "maxLength": cocos_editor_bridge::MAX_EXECUTE_CODE_BYTES } }, + "required": ["code"], + "additionalProperties": false + } + })); + tools.extend( + cocos_editor_bridge::cocos_operation_catalog() + .iter() + .cloned(), + ); + } if controlled_web_search { tools.push(json!({ "name": "agc_web_search", @@ -503,6 +546,21 @@ fn validate_write_file_arguments(arguments: &Value) -> Result<(), String> { normalize_relative_path(&path).map(|_| ()) } +#[cfg(all(windows, feature = "cocos-editor-execute"))] +async fn call_agc_cocos_execute(arguments: &Value) -> Value { + let validated = validate_tool_object_fields(arguments, &["code"]).and_then(|()| { + let code = arguments + .get("code") + .and_then(Value::as_str) + .ok_or_else(|| "code 必须是 JavaScript 函数体".to_string())?; + cocos_editor_bridge::validate_execute_code(code).map_err(|error| error.to_string()) + }); + if let Err(error) = validated { + return mcp_tool_result(error, Vec::new(), true); + } + call_client_tool_bridge("agc_cocos_execute", arguments).await +} + fn mcp_success(id: Value, result: Value) -> Value { json!({ "jsonrpc": "2.0", "id": id, "result": result }) } @@ -1335,7 +1393,12 @@ fn external_mcp_record_response(root: &Path, arguments: &Value) -> Value { true, ); } - let _project_lock = match acquire_project_write_lock(root, "conversation.write") { + // 与 DirectProject 历史落盘同一档有界等待：`agc_write_file` 持锁期间可能持续数秒， + // 零等待取锁会让 Codex 返回记录直接丢失。调用方已把本函数放进阻塞线程池。 + let _project_lock = match acquire_game_creator_agent_runtime_project_write_lock_with_wait( + root, + "conversation.write", + ) { Ok(lock) => lock, Err(error) => { return mcp_tool_result(format!("项目对话锁不可用：{error}"), Vec::new(), true) @@ -1556,7 +1619,7 @@ async fn handle_direct_tools_mcp_request(root: &Path, request: Value) -> Option< )) } } - "tools/list" => Some(mcp_success(id, direct_tools_mcp_specs())), + "tools/list" => Some(mcp_success(id, direct_tools_mcp_specs().await)), "tools/call" => { let tool = request .pointer("/params/name") @@ -1569,12 +1632,33 @@ async fn handle_direct_tools_mcp_request(root: &Path, request: Value) -> Option< let result = match tool { "client.session.info" => external_mcp_session_info(root), "conversation.record_codex_response" => { - external_mcp_record_response(root, &arguments) + // 取锁等待是同步轮询（最多约 10 秒），必须放到阻塞线程池， + // 否则会占住 runtime worker。 + let journal_root = root.to_path_buf(); + let journal_arguments = arguments.clone(); + match tokio::task::spawn_blocking(move || { + external_mcp_record_response(&journal_root, &journal_arguments) + }) + .await + { + Ok(result) => result, + Err(error) => mcp_tool_result( + format!("Codex 返回记录任务未返回：{error}"), + Vec::new(), + true, + ), + } } "conversation.list" => external_mcp_conversation_list(root, &arguments), "conversation.read" => external_mcp_conversation_read(root, &arguments), "agc_read_skill_resource" => call_agc_read_skill_resource(&arguments), "agc_write_file" => call_agc_write_file(&arguments).await, + #[cfg(all(windows, feature = "cocos-editor-execute"))] + "agc_cocos_execute" => call_agc_cocos_execute(&arguments).await, + #[cfg(all(windows, feature = "cocos-editor-execute"))] + operation if cocos_editor_bridge::is_cocos_operation(operation) => { + call_client_tool_bridge(operation, &arguments).await + } "taonier_prepare_game_art" => call_taonier_prepare_game_art(&arguments).await, "agc_generate_image" => call_agc_generate_image(&arguments).await, "agc_edit_image" => call_agc_edit_image(&arguments).await, @@ -1767,8 +1851,250 @@ pub(crate) fn stop_game_creator_external_mcp() -> Result<(), String> { #[cfg(test)] mod tests { use super::*; + + #[cfg(all(windows, feature = "cocos-editor-execute"))] + #[test] + fn builtin_mcp_process_probe() { + let Ok(expected) = std::env::var("AGC_MCP_TEST_COCOS_EXPECTED") else { + return; + }; + assert!(crate::game_creator_runtime_config_dir().is_none()); + let runtime = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + .unwrap(); + let specs = runtime.block_on(direct_tools_mcp_specs()); + assert_eq!( + specs["tools"] + .as_array() + .unwrap() + .iter() + .any(|tool| tool["name"] == "agc_cocos_execute"), + expected == "true" + ); + assert_eq!( + specs["tools"] + .as_array() + .unwrap() + .iter() + .filter(|tool| tool["name"] + .as_str() + .is_some_and(cocos_editor_bridge::is_cocos_operation)) + .count(), + if expected == "true" { 36 } else { 0 } + ); + } + + #[cfg(all(windows, feature = "cocos-editor-execute"))] + #[tokio::test] + async fn builtin_tools_follow_host_switch_in_isolated_mcp_processes() { + let _guard = crate::builtin_plugins::test_lock(); + let config = tempfile::tempdir().unwrap(); + crate::builtin_plugins::initialize(config.path()).unwrap(); + let project = crate::tests::canonical_test_tempdir("builtin-mcp-project-"); + // 本用例只访问可用工具摘要和禁用入口，无需初始化完整游戏项目。 + std::fs::create_dir_all(project.path().join(".agent")).unwrap(); + std::fs::write(project.path().join(".agent/manifest.json"), "{}").unwrap(); + let bridge = + super::super::direct_tool_bridge::start_direct_tool_bridge(project.path(), false) + .await + .unwrap(); + for enabled in [false, true, false, true] { + crate::builtin_plugins::set_enabled( + crate::builtin_plugins::AGC_COCOS_EDITOR_PLUGIN_ID, + enabled, + ) + .unwrap(); + // 同一个 MCP 服务重复 tools/list，同时覆盖原生函数永久缓存的切换。 + let specs = EXTERNAL_MCP_BRIDGE_URL + .scope(bridge.url().to_string(), direct_tools_mcp_specs()) + .await; + assert_eq!( + specs["tools"] + .as_array() + .unwrap() + .iter() + .any(|tool| tool["name"] == "agc_cocos_execute"), + enabled + ); + assert_eq!( + crate::agent_native_tools::native_runtime_function_name( + crate::builtin_plugins::AGC_COCOS_EDITOR_TOOL_NAME + ) + .is_some(), + enabled + ); + if !enabled { + for tool in cocos_editor_bridge::cocos_operation_catalog() { + let response = EXTERNAL_MCP_BRIDGE_URL + .scope( + bridge.url().to_string(), + call_client_tool_bridge(tool["name"].as_str().unwrap(), &json!({})), + ) + .await; + assert_eq!(response["isError"], true); + assert!(response.to_string().contains("插件已禁用")); + } + let response = EXTERNAL_MCP_BRIDGE_URL + .scope( + bridge.url().to_string(), + call_agc_cocos_execute(&json!({"code":"return 1;"})), + ) + .await; + assert_eq!(response["isError"], true); + assert!(response.to_string().contains("插件已禁用")); + } + // 子进程没有真实 AppData，必须只从绑定宿主获取可用性。 + let url = bridge.url().to_string(); + let result = tokio::task::spawn_blocking(move || { + std::process::Command::new(std::env::current_exe().unwrap()) + .args([ + "--exact", + "agent::direct_tools_mcp::tests::builtin_mcp_process_probe", + "--nocapture", + ]) + .env(DIRECT_TOOL_BRIDGE_URL_ENV, url) + .env("AGC_MCP_TEST_COCOS_EXPECTED", enabled.to_string()) + .output() + .unwrap() + }) + .await + .unwrap(); + assert!( + result.status.success(), + "{} {}", + String::from_utf8_lossy(&result.stdout), + String::from_utf8_lossy(&result.stderr) + ); + assert!( + String::from_utf8_lossy(&result.stdout).contains("1 passed"), + "child probe must run" + ); + } + std::fs::write(config.path().join("extensions/builtin-plugins.json"), "{").unwrap(); + let specs = EXTERNAL_MCP_BRIDGE_URL + .scope(bridge.url().to_string(), direct_tools_mcp_specs()) + .await; + assert!(!specs.to_string().contains("agc_cocos_execute")); + drop(bridge); + let specs = EXTERNAL_MCP_BRIDGE_URL + .scope( + "http://127.0.0.1:1/tool-unavailable".to_string(), + direct_tools_mcp_specs(), + ) + .await; + assert!(!specs.to_string().contains("agc_cocos_execute")); + } use std::io::{Read, Write}; + #[cfg(all(windows, feature = "cocos-editor-execute"))] + #[tokio::test] + #[ignore = "显式指定已打开的自有 Cocos smoke 工程后运行"] + async fn cocos_real_tools_list_and_call() { + let _guard = crate::builtin_plugins::test_lock(); + let root = + PathBuf::from(std::env::var("AGC_COCOS_TEST_PROJECT").expect("explicit smoke root")) + .canonicalize() + .unwrap(); + let package: Value = + serde_json::from_slice(&std::fs::read(root.join("package.json")).unwrap()).unwrap(); + assert_eq!( + package["name"], "agc-cocos-capability-smoke", + "只操作自有测试工程" + ); + let config = tempfile::tempdir().unwrap(); + crate::builtin_plugins::initialize(config.path()).unwrap(); + std::fs::create_dir_all(root.join(".agent")).unwrap(); + if !root.join(".agent/manifest.json").exists() { + std::fs::write(root.join(".agent/manifest.json"), "{}").unwrap(); + } + let bridge = super::super::direct_tool_bridge::start_direct_tool_bridge(&root, false) + .await + .unwrap(); + let tools = EXTERNAL_MCP_BRIDGE_URL + .scope(bridge.url().to_string(), direct_tools_mcp_specs()) + .await; + assert_eq!( + tools["tools"] + .as_array() + .unwrap() + .iter() + .filter(|t| t["name"] + .as_str() + .is_some_and(cocos_editor_bridge::is_cocos_operation)) + .count(), + 36 + ); + async fn invoke(root: &Path, url: &str, name: &str, args: Value) -> Value { + let reply = EXTERNAL_MCP_BRIDGE_URL.scope(url.to_string(), handle_direct_tools_mcp_request(root, json!({ + "jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":name,"arguments":args} + }))).await.unwrap(); + assert_eq!(reply["result"]["isError"], false, "{name}: {reply}"); + reply["result"].clone() + } + let ping = invoke(&root, bridge.url(), "cocos_ping", json!({})).await; + assert!(ping.to_string().contains("ready")); + let hierarchy = invoke(&root, bridge.url(), "cocos_get_hierarchy", json!({})).await; + let parsed: Value = + serde_json::from_str(hierarchy["content"][0]["text"].as_str().unwrap()).unwrap(); + let tree = &parsed["result"]["result"]["tree"]; + let canvas = tree["children"] + .as_array() + .unwrap() + .iter() + .find(|n| n["name"] == "Canvas") + .unwrap(); + invoke( + &root, + bridge.url(), + "cocos_create_ui_label", + json!({ + "parentNid":canvas["uuid"], "name":"AGC_MCP_SMOKE", "text":"MCP", "save":false + }), + ) + .await; + invoke(&root, bridge.url(), "cocos_mcp_undo_last", json!({})).await; + if let Ok(url) = std::env::var("AGC_COCOS_TEST_PREVIEW_URL") { + invoke( + &root, + bridge.url(), + "cocos_preview_debug_start", + json!({"url":url}), + ) + .await; + let capture = invoke( + &root, + bridge.url(), + "cocos_preview_debug_capture", + json!({}), + ) + .await; + assert!(capture["content"] + .as_array() + .unwrap() + .iter() + .any(|b| b["type"] == "image" && b["mimeType"] == "image/png")); + invoke(&root, bridge.url(), "cocos_preview_debug_stop", json!({})).await; + } + let final_tree = invoke(&root, bridge.url(), "cocos_get_hierarchy", json!({})).await; + assert!(!final_tree.to_string().contains("AGC_MCP_SMOKE")); + } + + #[test] + fn cocos_mcp_schemas_accept_real_arguments_and_reject_unknown_fields() { + for tool in cocos_editor_bridge::cocos_operation_catalog() { + let validator = jsonschema::validator_for(&tool["inputSchema"]).unwrap(); + assert!(!validator.is_valid(&json!({"unregistered-field":1}))); + } + let ui = cocos_editor_bridge::cocos_operation_catalog() + .iter() + .find(|t| t["name"] == "cocos_apply_ui_spec") + .unwrap(); + let validator = jsonschema::validator_for(&ui["inputSchema"]).unwrap(); + assert!(validator.is_valid(&json!({"parentNid":1,"nodes":[{"kind":"container","children":[{"kind":"label","text":"测试"}]}],"save":false}))); + assert!(!validator.is_valid(&json!({"parentNid":1,"nodes":[{"kind":"shell-command"}]}))); + } + #[tokio::test] async fn loopback_tool_bridge_client_omits_agc_marker() { let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind loopback fixture"); @@ -1842,7 +2168,7 @@ mod tests { DIRECT_TOOLS_MCP_MAX_REQUEST_BYTES > DIRECT_TOOLS_MCP_MAX_WRITE_CONTENT_BYTES + 1024, "MCP request envelope must fit the advertised file-write payload" ); - let specs = direct_tools_mcp_specs_for(false); + let specs = direct_tools_mcp_specs_for(false, true); let names = specs["tools"] .as_array() .expect("tool array") @@ -1869,6 +2195,22 @@ mod tests { "agc_remove_background", "agc_browser_playtest", ] + .into_iter() + .chain( + cfg!(all(windows, feature = "cocos-editor-execute")).then_some("agc_cocos_execute") + ) + .chain( + cocos_editor_bridge::cocos_operation_catalog() + .iter() + .filter_map(|tool| { + if cfg!(all(windows, feature = "cocos-editor-execute")) { + tool["name"].as_str() + } else { + None + } + }) + ) + .collect::>() ); let serialized = specs.to_string(); assert!(!serialized.contains("agc_web_search")); @@ -1975,7 +2317,7 @@ mod tests { #[test] fn tool_catalog_adds_controlled_web_search_only_when_enabled() { - let specs = direct_tools_mcp_specs_for(true); + let specs = direct_tools_mcp_specs_for(true, true); let search = specs["tools"] .as_array() .expect("tool array") diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_audit.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_audit.rs index 235177a31..5c9afc1a4 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_audit.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_audit.rs @@ -1606,6 +1606,17 @@ pub(crate) fn agent_runtime_tool_action_input_summary( .unwrap_or(160) ), "command.run_limited" => format!("commandId={}", text(&["commandId", "command_id", "id"])), + "cocos.editor.execute" => format!( + "codeChars={} · codeSha256={:x}", + chars(&["code"]), + Sha256::digest( + input + .get("code") + .and_then(serde_json::Value::as_str) + .unwrap_or_default() + .as_bytes() + ) + ), "preview.validate" => { let viewports = input .get("viewports") diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_execution.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_execution.rs index 75e545171..620aec6df 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_execution.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/action_execution.rs @@ -66,12 +66,10 @@ pub(crate) async fn execute_game_creator_agent_runtime_tool_action_with_pending_ return blocker; } } - if !relaxed_autonomous { - if let Some(blocker) = - agent_runtime_autonomous_art_director_canvas_only_action_block(agent_id, task, tool) - { - return blocker; - } + if let Some(blocker) = + agent_runtime_autonomous_art_director_canvas_only_action_block(agent_id, task, tool) + { + return blocker; } let command_id = game_creator_agent_runtime_tool_command_id(tool); if let Some(command_id) = command_id { @@ -364,6 +362,16 @@ pub(crate) async fn execute_game_creator_agent_runtime_tool_action_with_pending_ observe_agent_runtime_limited_command(root, agent_id, run_id, &action.input) } "preview.start" => observe_agent_runtime_preview_start(root, agent_id, run_id), + "cocos.editor.execute" => observe_agent_runtime_project_snapshot_with_lock( + root, + agent_id, + run_id, + action, + &action_fingerprint, + pending_action, + true, + || observe_agent_runtime_cocos_editor_execute(root, action, pending_action), + ), "preview.validate" => { observe_agent_runtime_preview_validate( root, diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/parallel_ledger.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/parallel_ledger.rs index 48858c55c..e1fe9f4a9 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/parallel_ledger.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/parallel_ledger.rs @@ -95,6 +95,8 @@ pub(in crate::agent) fn game_creator_agent_runtime_tool_command_id( "command.stdin" => Some("command.stdin"), "command.terminate" => Some("command.terminate"), "command.run_limited" => Some("command.run_limited"), + #[cfg(feature = "cocos-editor-execute")] + "cocos.editor.execute" => Some("cocos.editor.execute"), "preview.start" => Some("preview.start"), "preview.validate" => Some("preview.validate"), "image.inspect" => Some("image.inspect"), diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/project_gates.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/project_gates.rs index d4e7fde49..4d4727ac9 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/project_gates.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/project_gates.rs @@ -138,12 +138,16 @@ pub(crate) fn ensure_current_autonomous_ready_child_mutation_at_locked( if game_creator_agent_runtime_cancel_requested_for(root, &normalized_agent_id, run_id) { return Err("当前 Run 已收到取消请求，禁止继续修改项目".to_string()); } - if autonomous_relaxed_run_at(root, &normalized_agent_id, run_id)? { - return Ok(()); - } + let relaxed_autonomous = autonomous_relaxed_run_at(root, &normalized_agent_id, run_id)?; let binding = read_game_creator_agent_runtime_run_profile_binding(root, &normalized_agent_id, run_id)?; let Some(binding) = binding else { + if relaxed_autonomous { + // Keep the relaxed lane compatible with legacy runs that predate + // durable Run Profile sidecars; bound runs still receive the + // current-root and lineage checks below. + return Ok(()); + } let task = read_latest_game_creator_agent_runtime_task_by_run_id( root, &normalized_agent_id, diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/tool_policy_snapshot.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/tool_policy_snapshot.rs index 539eb45d7..1c2fb8d7f 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/tool_policy_snapshot.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_actions/tool_policy_snapshot.rs @@ -17,7 +17,7 @@ mod canvas_asset_kind_contract_tests { } pub(crate) fn agent_runtime_executable_tools() -> Vec<&'static str> { - vec![ + let mut tools = vec![ GAME_CREATOR_USER_INPUT_REQUEST_TOOL, "memory.read", "memory.write", @@ -63,7 +63,13 @@ pub(crate) fn agent_runtime_executable_tools() -> Vec<&'static str> { "agent.schedule_ready", "agent.action_history", "agent.run_status", - ] + ]; + // 内置插件被用户禁用后，对应 Runtime 工具不再进入工具目录、Agent 上下文 + // 和工具策略快照。 + if crate::builtin_plugins::cocos_editor_agent_tool_available() { + tools.push(crate::builtin_plugins::AGC_COCOS_EDITOR_TOOL_NAME); + } + tools } pub(crate) fn agent_runtime_native_executable_tools() -> Vec<&'static str> { @@ -173,6 +179,16 @@ pub(in crate::agent) fn agent_runtime_tool_policy_snapshot_at( auto_tools.push(tool.to_string()); } } + if isolated { + // Keep the isolated-child contract explicit even when a denied tool + // is unavailable on the current platform and therefore absent from + // the executable catalog (for example, the Windows-only Cocos bridge). + for tool in ISOLATED_AGENT_UNSCOPED_DENIED_TOOLS { + if !denied_tools.iter().any(|candidate| candidate == tool) { + denied_tools.push((*tool).to_string()); + } + } + } Ok(AgentRuntimeToolPolicySnapshot { run_profile: default_agent_runtime_run_profile(), run_profile_binding_fingerprint: String::new(), diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_policy_v2.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_policy_v2.rs index ed29b95d3..4b588acfb 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_policy_v2.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_policy_v2.rs @@ -1908,7 +1908,7 @@ mod tests { ) .expect("first persist"); rewind_session_keep_gdd_file(&root, &session); - let hydrated = hydrate_planning_session_v2( + let hydrated = hydrate_planning_session_v2_sync( root.to_string_lossy().to_string(), Some(session.session_id.clone()), ) diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_session_v2.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_session_v2.rs index 765a14a82..0d5aa7239 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_session_v2.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_protocol/planning_session_v2.rs @@ -1465,7 +1465,18 @@ async fn run_planning_session_v2_command( } #[tauri::command] -pub(crate) fn hydrate_planning_session_v2( +pub(crate) async fn hydrate_planning_session_v2( + project_path: String, + session_id: Option, +) -> Result, String> { + tauri::async_runtime::spawn_blocking(move || { + hydrate_planning_session_v2_sync(project_path, session_id) + }) + .await + .map_err(|error| format!("恢复 Planning V2 后台任务失败：{error}"))? +} + +pub(crate) fn hydrate_planning_session_v2_sync( project_path: String, session_id: Option, ) -> Result, String> { diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools.rs index 633f5ffe8..41235d21e 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools.rs @@ -1,6 +1,7 @@ use super::*; mod action_history; +mod cocos_editor; mod command_ops; mod context; mod delegation; @@ -20,6 +21,7 @@ mod task_ops; mod ui_workflow; pub(in crate::agent) use action_history::*; +pub(in crate::agent) use cocos_editor::*; pub(in crate::agent) use command_ops::*; pub(in crate::agent) use context::*; pub(in crate::agent) use delegation::*; diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/cocos_editor.rs b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/cocos_editor.rs new file mode 100644 index 000000000..5cf29088e --- /dev/null +++ b/apps/ai-game-creator-shell/src-tauri/src/agent/runtime_tools/cocos_editor.rs @@ -0,0 +1,117 @@ +use super::*; + +#[derive(Debug, Deserialize)] +#[serde(deny_unknown_fields, rename_all = "camelCase")] +struct CocosEditorExecuteInput { + code: String, +} + +pub(in crate::agent) fn observe_agent_runtime_cocos_editor_execute( + root: &Path, + action: &AgentRuntimeToolAction, + pending_action: Option<&AgentRuntimePendingToolAction>, +) -> AgentRuntimeToolObservation { + let input = match serde_json::from_value::(action.input.clone()) { + Ok(input) => input, + Err(error) => { + return AgentRuntimeToolObservation { + tool: "cocos.editor.execute".to_string(), + status: "failed".to_string(), + summary: sanitize_agent_runtime_text( + &format!("cocos.editor.execute 输入无效：{error}"), + 240, + ), + detail: None, + }; + } + }; + if pending_action.is_none() { + return AgentRuntimeToolObservation { + tool: "cocos.editor.execute".to_string(), + status: "failed".to_string(), + summary: "cocos.editor.execute 必须绑定 durable pending action".to_string(), + detail: None, + }; + } + if !crate::builtin_plugins::cocos_editor_agent_tool_available() { + return AgentRuntimeToolObservation { + tool: "cocos.editor.execute".to_string(), + status: "failed".to_string(), + summary: "Cocos Creator 插件已禁用".to_string(), + detail: None, + }; + } + let response = match cocos_editor_bridge::execute_cocos_editor_code_for_project( + root.to_string_lossy().as_ref(), + &input.code, + cocos_editor_bridge::DEFAULT_COMMAND_TIMEOUT_MS, + ) { + Ok(response) => response, + Err(error) => { + let uncertain = matches!( + &error, + cocos_editor_bridge::BridgeError::ExecutionUncertain(_) + ); + return AgentRuntimeToolObservation { + tool: "cocos.editor.execute".to_string(), + status: if uncertain { + AGENT_RUNTIME_TOOL_OBSERVATION_STATUS_NEEDS_RECONCILIATION + } else { + "failed" + } + .to_string(), + summary: redact_agent_runtime_project_paths(root, &error.to_string(), 240), + detail: Some( + serde_json::json!({ + "codeChars": input.code.chars().count(), + "error": redact_agent_runtime_project_paths(root, &error.to_string(), 500), + }) + .to_string(), + ), + }; + } + }; + let ok = response.ok; + let detail = serde_json::json!({ + "processId": response.process_id, + "requestId": response.request_id, + "ok": ok, + "result": response.result.clone(), + "error": response.error.clone(), + "codeChars": input.code.chars().count(), + }) + .to_string(); + AgentRuntimeToolObservation { + tool: "cocos.editor.execute".to_string(), + status: if ok { "ok" } else { "failed" }.to_string(), + summary: if ok { + format!( + "已在 Cocos Creator 执行 {} 字符代码", + input.code.chars().count() + ) + } else { + "Cocos Creator execute 返回失败".to_string() + }, + detail: Some(detail), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn execute_requires_durable_pending_action_before_touching_editor() { + let action = AgentRuntimeToolAction { + tool: "cocos.editor.execute".to_string(), + reason: Some("test".to_string()), + input: serde_json::json!({"code": "return 1 + 1;"}), + }; + let observation = + observe_agent_runtime_cocos_editor_execute(Path::new("C:\\cocos"), &action, None); + assert_eq!(observation.status, "failed"); + assert!(observation + .summary + .contains("必须绑定 durable pending action")); + } +} diff --git a/apps/ai-game-creator-shell/src-tauri/src/agent_native_tools.rs b/apps/ai-game-creator-shell/src-tauri/src/agent_native_tools.rs index 68ce6d844..6a35ce93e 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/agent_native_tools.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/agent_native_tools.rs @@ -231,8 +231,10 @@ fn native_runtime_function_name_for_tool(tool: &str) -> String { ) } -fn build_agent_runtime_native_capability_registry() -> Result, String> { - let definitions = agent_runtime_native_executable_tools() +fn build_agent_runtime_native_capability_registry( + tools: Vec<&'static str>, +) -> Result, String> { + let definitions = tools .into_iter() .map(|tool| { CapabilityDefinition::try_new( @@ -251,9 +253,20 @@ fn build_agent_runtime_native_capability_registry() -> Result Result<&'static CapabilityRegistry, String> { - static REGISTRY: OnceLock, String>> = OnceLock::new(); - REGISTRY - .get_or_init(build_agent_runtime_native_capability_registry) + // 内置插件开关会改变工具目录，因此按“可用 / 不可用”各缓存一份：切换后立即 + // 生效，又不需要每次调用都重建 registry。 + static ENABLED_REGISTRY: OnceLock, String>> = OnceLock::new(); + static DISABLED_REGISTRY: OnceLock, String>> = + OnceLock::new(); + // 缓存选择与构建消费同一份快照，避免开关变化污染另一份永久缓存。 + let tools = agent_runtime_native_executable_tools(); + let cache = if tools.contains(&crate::builtin_plugins::AGC_COCOS_EDITOR_TOOL_NAME) { + &ENABLED_REGISTRY + } else { + &DISABLED_REGISTRY + }; + cache + .get_or_init(|| build_agent_runtime_native_capability_registry(tools)) .as_ref() .map_err(Clone::clone) } @@ -1027,6 +1040,9 @@ fn runtime_tool_description(tool: &str) -> &'static str { "ui.workflow.run" => { "先用 discover 从受控 game/ui-pages.json 或页面声明标记自动发现全部功能页面，再把已登记 ui-prototype 与每个页面的设计图桥接成独立 UI JSON State；可同时载入已登记图片、图标和项目字体，执行 Provider 结构识别、多树合并与分批组件绑定、回读阶段，并且只有所有页面已绑定且已应用到 game/ 后才允许 finalize。项目根目录由 Runtime 注入，模型不得传入宿主路径。" } + "cocos.editor.execute" => { + "在当前项目对应的已打开 Cocos Creator 编辑器中执行一段有界代码；Runtime 自动绑定唯一匹配的 Creator 主进程，代码与结果都通过注入 payload 的本机 bridge 返回。" + } "blackboard.write" => "向项目级共享黑板追加稳定结论。", "agent.message" => "向一个目标 Agent 写入定向上下文消息。", "agent.delegate" => { @@ -1216,6 +1232,14 @@ fn runtime_tool_input_schema(tool: &str) -> Value { } }), "command.exec" | "command.start" => command_start_input_schema(), + "cocos.editor.execute" => json!({ + "type": "object", + "required": ["code"], + "additionalProperties": false, + "properties": { + "code": { "type": "string", "minLength": 1, "maxLength": 131072 } + } + }), "command.output_read" => json!({ "type": "object", "required": ["actionId", "startLine", "maxLines"], "additionalProperties": false, "properties": { diff --git a/apps/ai-game-creator-shell/src-tauri/src/builtin_plugins.rs b/apps/ai-game-creator-shell/src-tauri/src/builtin_plugins.rs new file mode 100644 index 000000000..5e34469f5 --- /dev/null +++ b/apps/ai-game-creator-shell/src-tauri/src/builtin_plugins.rs @@ -0,0 +1,438 @@ +//! 内置插件登记表与可用开关。 +//! +//! 内置插件随 `plugins/` 工作区随包分发，用户不能卸载，只能控制是否可用。 +//! 开关状态持久化在 AppData `extensions/builtin-plugins.json`，同时被两处消费： +//! 插件宿主（禁用后不能启动，状态显示为 disabled）和 Agent 工具目录（禁用后 +//! 不出现在工具列表与 Agent 上下文里）。 + +use std::collections::BTreeMap; +use std::fs; +use std::path::{Path, PathBuf}; +use std::sync::{Mutex, OnceLock}; + +use serde::{Deserialize, Serialize}; + +/// Cocos Creator 编辑器插件的插件 id，与 `plugins/agc-cocos-editor/plugin.json` 一致。 +pub(crate) const AGC_COCOS_EDITOR_PLUGIN_ID: &str = "agc-cocos-editor"; + +/// 该插件在 Agent 侧对应的 Runtime 工具名。 +pub(crate) const AGC_COCOS_EDITOR_TOOL_NAME: &str = "cocos.editor.execute"; + +const STATE_FILE_NAME: &str = "builtin-plugins.json"; +const STATE_SCHEMA_VERSION: &str = "agc.builtin-plugins.v1"; + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) enum BuiltinPlugin { + CocosEditor, +} + +impl BuiltinPlugin { + pub(crate) fn id(self) -> &'static str { + match self { + Self::CocosEditor => AGC_COCOS_EDITOR_PLUGIN_ID, + } + } + + /// 未持久化任何开关时的默认状态。 + fn default_enabled(self) -> bool { + match self { + Self::CocosEditor => true, + } + } + + /// 该插件是否向 Agent 暴露 Runtime 工具。 + fn exposes_agent_tools(self) -> bool { + match self { + Self::CocosEditor => true, + } + } +} + +pub(crate) const BUILTIN_PLUGINS: &[BuiltinPlugin] = &[BuiltinPlugin::CocosEditor]; + +pub(crate) fn builtin_plugin(id: &str) -> Option { + BUILTIN_PLUGINS + .iter() + .copied() + .find(|plugin| plugin.id() == id.trim()) +} + +pub(crate) fn is_builtin(id: &str) -> bool { + builtin_plugin(id).is_some() +} + +#[derive(Debug, Default)] +struct BuiltinPluginState { + path: Option, + enabled: BTreeMap, + /// 开关文件不可读或格式不受支持时，内置插件全部按不可用处理。 + fail_closed: bool, +} + +static STATE: OnceLock> = OnceLock::new(); + +fn state() -> &'static Mutex { + STATE.get_or_init(|| Mutex::new(BuiltinPluginState::default())) +} + +#[derive(Debug, Default, Deserialize, Serialize)] +#[serde(rename_all = "camelCase")] +struct BuiltinPluginStateFile { + #[serde(default)] + schema_version: Option, + #[serde(default)] + enabled: BTreeMap, +} + +/// 读取 AppData 里的开关状态；文件缺失按默认状态处理，坏文件失败关闭。 +pub(crate) fn initialize(config_dir: &Path) -> Result<(), String> { + let root = config_dir.join("extensions"); + let path = root.join(STATE_FILE_NAME); + if let Err(error) = fs::create_dir_all(&root) { + mark_fail_closed(Some(path)); + return Err(format!("准备内置插件目录失败：{error}")); + } + let mut guard = state() + .lock() + .map_err(|_| "内置插件状态锁已损坏".to_string())?; + guard.path = Some(path.clone()); + reload_state(&mut guard, &path) +} + +fn read_state_file(path: &Path) -> Result { + match fs::read(path) { + Ok(bytes) => match serde_json::from_slice::(&bytes) { + Ok(file) if file.schema_version.as_deref() == Some(STATE_SCHEMA_VERSION) => Ok(file), + Ok(_) => Err(format!( + "内置插件开关文件版本不受支持，需要 {STATE_SCHEMA_VERSION}" + )), + Err(error) => Err(format!("内置插件开关文件无效：{error}")), + }, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => { + Ok(BuiltinPluginStateFile::default()) + } + Err(error) => Err(format!("读取内置插件开关失败：{error}")), + } +} + +fn reload_state(guard: &mut BuiltinPluginState, path: &Path) -> Result<(), String> { + let loaded = match read_state_file(path) { + Ok(loaded) => loaded, + Err(error) => { + guard.fail_closed = true; + guard.enabled = BUILTIN_PLUGINS + .iter() + .map(|plugin| (plugin.id().to_string(), false)) + .collect(); + return Err(error); + } + }; + guard.fail_closed = false; + // 只接受登记表里的 id，避免坏文件把未知对象带进运行时。 + guard.enabled = loaded + .enabled + .into_iter() + .filter(|(id, _)| is_builtin(id)) + .collect(); + Ok(()) +} + +fn mark_fail_closed(path: Option) { + if let Ok(mut guard) = state().lock() { + guard.path = path; + guard.fail_closed = true; + guard.enabled = BUILTIN_PLUGINS + .iter() + .map(|plugin| (plugin.id().to_string(), false)) + .collect(); + } +} + +pub(crate) fn is_enabled(id: &str) -> bool { + let Some(plugin) = builtin_plugin(id) else { + return false; + }; + // Runner/CLI 已绑定配置根，但不会执行 GUI setup；不推断隔离子进程的 AppData。 + let config_dir = crate::game_creator_runtime_config_dir_lock() + .lock() + .ok() + .and_then(|path| path.clone()); + state() + .lock() + .map(|mut guard| { + let Some(path) = guard + .path + .clone() + .or_else(|| config_dir.map(|root| root.join("extensions").join(STATE_FILE_NAME))) + else { + return false; + }; + // 每次查询读取持久化权威，使运行中的其它进程立即感知开关变化。 + let _ = reload_state(&mut guard, &path); + if guard.fail_closed { + return false; + } + guard + .enabled + .get(plugin.id()) + .copied() + .unwrap_or_else(|| plugin.default_enabled()) + }) + // 状态锁损坏时同样 fail-closed，避免异常状态重新放开内置能力。 + .unwrap_or(false) +} + +/// 内置插件的用户开关；`None` 表示该 id 不是内置插件，由来源自己决定启用状态。 +pub(crate) fn toggle_state(id: &str) -> Option { + builtin_plugin(id).map(|_| is_enabled(id)) +} + +pub(crate) fn set_enabled(id: &str, enabled: bool) -> Result { + let Some(plugin) = builtin_plugin(id) else { + return Err(format!("{id} 不是内置插件，不能使用内置插件开关")); + }; + let mut guard = state() + .lock() + .map_err(|_| "内置插件状态锁已损坏".to_string())?; + let path = guard + .path + .clone() + .ok_or_else(|| "内置插件开关尚未初始化".to_string())?; + // 保留其它进程刚写入的开关；损坏文件按全部禁用起步，允许用户显式修复。 + let _ = reload_state(&mut guard, &path); + let previous = guard.enabled.get(plugin.id()).copied(); + guard.enabled.insert(plugin.id().to_string(), enabled); + if let Err(error) = persist(&guard) { + match previous { + Some(value) => { + guard.enabled.insert(plugin.id().to_string(), value); + } + None => { + guard.enabled.remove(plugin.id()); + } + } + return Err(error); + } + guard.fail_closed = false; + Ok(enabled) +} + +fn persist(guard: &BuiltinPluginState) -> Result<(), String> { + let path = guard + .path + .clone() + .ok_or_else(|| "内置插件开关尚未初始化".to_string())?; + let file = BuiltinPluginStateFile { + schema_version: Some(STATE_SCHEMA_VERSION.to_string()), + enabled: guard.enabled.clone(), + }; + let bytes = serde_json::to_vec_pretty(&file) + .map_err(|error| format!("序列化内置插件开关失败：{error}"))?; + let temporary = path.with_extension("json.tmp"); + fs::write(&temporary, bytes).map_err(|error| format!("写入内置插件开关失败：{error}"))?; + fs::rename(&temporary, &path).map_err(|error| format!("提交内置插件开关失败：{error}"))?; + Ok(()) +} + +/// Agent 工具面是否可用：编译期 feature 打开且用户没有禁用该内置插件。 +pub(crate) fn agent_tool_available(plugin: BuiltinPlugin) -> bool { + plugin.exposes_agent_tools() + && cfg!(feature = "cocos-editor-execute") + && is_enabled(plugin.id()) +} + +pub(crate) fn cocos_editor_agent_tool_available() -> bool { + agent_tool_available(BuiltinPlugin::CocosEditor) +} + +pub(crate) fn available_agent_tools() -> Vec<&'static str> { + if cocos_editor_agent_tool_available() { + let mut tools = vec![AGC_COCOS_EDITOR_TOOL_NAME]; + tools.extend( + cocos_editor_bridge::cocos_operation_catalog() + .iter() + .filter_map(|tool| tool["name"].as_str()), + ); + tools + } else { + Vec::new() + } +} + +#[cfg(test)] +pub(crate) use tests::test_lock; + +#[cfg(test)] +mod tests { + use super::*; + use tempfile::tempdir; + + pub(crate) fn test_lock() -> std::sync::MutexGuard<'static, ()> { + static LOCK: OnceLock> = OnceLock::new(); + LOCK.get_or_init(|| Mutex::new(())) + .lock() + .unwrap_or_else(|error| error.into_inner()) + } + + #[test] + fn builtin_plugins_default_to_enabled_and_reject_unknown_ids() { + let _guard = test_lock(); + let directory = tempdir().expect("temp config"); + initialize(directory.path()).expect("initialize"); + assert!(is_builtin(AGC_COCOS_EDITOR_PLUGIN_ID)); + assert!(is_enabled(AGC_COCOS_EDITOR_PLUGIN_ID)); + assert_eq!(toggle_state(AGC_COCOS_EDITOR_PLUGIN_ID), Some(true)); + assert_eq!(toggle_state("imported-plugin"), None); + assert!(!is_enabled("imported-plugin")); + assert!(set_enabled("imported-plugin", false).is_err()); + } + + #[test] + fn toggle_state_round_trips_through_appdata_file() { + let _guard = test_lock(); + let directory = tempdir().expect("temp config"); + initialize(directory.path()).expect("initialize"); + assert_eq!( + set_enabled(AGC_COCOS_EDITOR_PLUGIN_ID, false).expect("disable"), + false + ); + let path = directory.path().join("extensions").join(STATE_FILE_NAME); + let written = fs::read_to_string(&path).expect("state file"); + assert!(written.contains(STATE_SCHEMA_VERSION)); + assert!(written.contains(AGC_COCOS_EDITOR_PLUGIN_ID)); + + // 重新初始化模拟下次启动读取持久化结果。 + initialize(directory.path()).expect("re-initialize"); + assert!(!is_enabled(AGC_COCOS_EDITOR_PLUGIN_ID)); + set_enabled(AGC_COCOS_EDITOR_PLUGIN_ID, true).expect("enable"); + assert!(is_enabled(AGC_COCOS_EDITOR_PLUGIN_ID)); + } + + #[test] + fn corrupt_state_file_fails_closed() { + let _guard = test_lock(); + let directory = tempdir().expect("temp config"); + let root = directory.path().join("extensions"); + fs::create_dir_all(&root).expect("extensions dir"); + fs::write(root.join(STATE_FILE_NAME), "{ not json").expect("write corrupt state"); + assert!(initialize(directory.path()).is_err()); + assert!(!is_enabled(AGC_COCOS_EDITOR_PLUGIN_ID)); + assert_eq!(toggle_state(AGC_COCOS_EDITOR_PLUGIN_ID), Some(false)); + } + + #[test] + fn enabling_after_corruption_recovers_without_reinitializing() { + let _guard = test_lock(); + let directory = tempdir().unwrap(); + fs::create_dir_all(directory.path().join("extensions")).unwrap(); + fs::write( + directory.path().join("extensions/builtin-plugins.json"), + "{", + ) + .unwrap(); + assert!(initialize(directory.path()).is_err()); + set_enabled(AGC_COCOS_EDITOR_PLUGIN_ID, true).unwrap(); + assert!(is_enabled(AGC_COCOS_EDITOR_PLUGIN_ID)); + } + + #[test] + fn availability_reloads_changes_written_by_another_process() { + let _guard = test_lock(); + let directory = tempdir().unwrap(); + initialize(directory.path()).unwrap(); + let path = directory.path().join("extensions/builtin-plugins.json"); + for enabled in [false, true, false] { + fs::write( + &path, + serde_json::json!({ + "schemaVersion": STATE_SCHEMA_VERSION, + "enabled": {AGC_COCOS_EDITOR_PLUGIN_ID: enabled} + }) + .to_string(), + ) + .unwrap(); + assert_eq!(is_enabled(AGC_COCOS_EDITOR_PLUGIN_ID), enabled); + } + fs::write(&path, "{").unwrap(); + assert!(!is_enabled(AGC_COCOS_EDITOR_PLUGIN_ID)); + } + + #[test] + fn runner_process_reads_disabled_state_without_gui_setup() { + let _guard = test_lock(); + let directory = tempdir().unwrap(); + initialize(directory.path()).unwrap(); + set_enabled(AGC_COCOS_EDITOR_PLUGIN_ID, false).unwrap(); + let result = std::process::Command::new(std::env::current_exe().unwrap()) + .args([ + "--exact", + "builtin_plugins::tests::runner_process_probe", + "--nocapture", + ]) + .env("AGC_BUILTIN_TEST_CONFIG_DIR", directory.path()) + .output() + .unwrap(); + assert!( + result.status.success(), + "{}", + String::from_utf8_lossy(&result.stdout) + ); + assert!(String::from_utf8_lossy(&result.stdout).contains("1 passed")); + } + + #[test] + fn runner_process_probe() { + let Some(config_dir) = std::env::var_os("AGC_BUILTIN_TEST_CONFIG_DIR") else { + return; + }; + // Runner/CLI 只绑定配置根目录，不进入 Tauri GUI setup。 + crate::set_game_creator_runtime_config_dir(PathBuf::from(config_dir)); + assert!(!is_enabled(AGC_COCOS_EDITOR_PLUGIN_ID)); + } + + #[test] + fn unsupported_schema_fails_closed() { + let _guard = test_lock(); + let directory = tempdir().expect("temp config"); + let root = directory.path().join("extensions"); + fs::create_dir_all(&root).expect("extensions dir"); + fs::write( + root.join(STATE_FILE_NAME), + serde_json::json!({"schemaVersion": "agc.builtin-plugins.v0", "enabled": {}}) + .to_string(), + ) + .expect("write unsupported state"); + assert!(initialize(directory.path()).is_err()); + assert!(!is_enabled(AGC_COCOS_EDITOR_PLUGIN_ID)); + } + + #[test] + fn agent_tool_visibility_follows_the_toggle() { + let _guard = test_lock(); + let directory = tempdir().expect("temp config"); + initialize(directory.path()).expect("initialize"); + let tool_visible_when_enabled = cfg!(feature = "cocos-editor-execute"); + + set_enabled(AGC_COCOS_EDITOR_PLUGIN_ID, true).expect("enable"); + assert_eq!( + cocos_editor_agent_tool_available(), + tool_visible_when_enabled + ); + assert_eq!( + crate::agent::agent_runtime_executable_tools().contains(&AGC_COCOS_EDITOR_TOOL_NAME), + tool_visible_when_enabled + ); + + set_enabled(AGC_COCOS_EDITOR_PLUGIN_ID, false).expect("disable"); + assert!(!cocos_editor_agent_tool_available()); + assert!( + !crate::agent::agent_runtime_executable_tools().contains(&AGC_COCOS_EDITOR_TOOL_NAME) + ); + + set_enabled(AGC_COCOS_EDITOR_PLUGIN_ID, true).expect("re-enable"); + assert_eq!( + crate::agent::agent_runtime_executable_tools().contains(&AGC_COCOS_EDITOR_TOOL_NAME), + tool_visible_when_enabled + ); + } +} diff --git a/apps/ai-game-creator-shell/src-tauri/src/client_extensions.rs b/apps/ai-game-creator-shell/src-tauri/src/client_extensions.rs index 5cf4c6f12..e3f7ce96e 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/client_extensions.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/client_extensions.rs @@ -23,6 +23,11 @@ pub(crate) struct ClientMcpRuntimeServer { pub(crate) config: BTreeMap, } +pub(crate) struct ClientPluginSource { + pub(crate) item: ClientExtensionItem, + pub(crate) root: PathBuf, +} + #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)] #[serde(rename_all = "camelCase")] pub(crate) struct ClientExtensionItem { @@ -169,7 +174,7 @@ fn claim_client_mcp_connection_at( let enabled_ids = index .items .iter() - .filter(|item| item.extension_type == "mcp" && item.enabled) + .filter(|item| item.extension_type == "mcp" && extension_effectively_enabled(&index, item)) .map(|item| item.id.as_str()) .collect::>(); let mut owners = client_mcp_connection_owners() @@ -294,6 +299,13 @@ fn sorted_directory_files(root: &Path) -> Result, String> if metadata.file_type().is_symlink() { return Err(format!("扩展目录不能包含符号链接：{}", path.display())); } + #[cfg(windows)] + { + use std::os::windows::fs::MetadataExt; + if metadata.file_attributes() & 0x400 != 0 { + return Err("扩展目录不能包含重解析点".to_string()); + } + } if metadata.is_dir() { visit(root, &path, entries)?; } else if metadata.is_file() { @@ -487,13 +499,34 @@ fn parse_mcp_config_file(path: &Path) -> Result .file_name() .and_then(|value| value.to_str()) .unwrap_or_default(); - if file_name.eq_ignore_ascii_case(".mcp.json") { + if file_name.eq_ignore_ascii_case(".mcp.json") || file_name.eq_ignore_ascii_case("mcp.json") { let Ok(content) = fs::read_to_string(path) else { return Ok(Vec::new()); }; let Ok(value) = serde_json::from_str::(&content) else { return Ok(Vec::new()); }; + if file_name.eq_ignore_ascii_case("mcp.json") { + if value.get("$schema").and_then(serde_json::Value::as_str) + != Some("https://agent-plugins.org/schemas/1.0.0/mcp.schema.json") + { + return Err("不支持的 Agent Plugins MCP schema".to_string()); + } + if let Some(servers) = value + .get("mcpServers") + .and_then(serde_json::Value::as_object) + { + for config in servers.values() { + match config.get("type").and_then(serde_json::Value::as_str) { + Some("stdio") + if config.get("command").is_some() && config.get("url").is_none() => {} + Some("streamable-http") + if config.get("url").is_some() && config.get("command").is_none() => {} + _ => return Err("Agent Plugins MCP transport 配置无效".to_string()), + } + } + } + } let Some(servers) = value .get("mcpServers") .and_then(serde_json::Value::as_object) @@ -530,7 +563,57 @@ fn parse_mcp_config_file(path: &Path) -> Result fn discover_candidates(payload: &Path) -> Result, String> { let files = sorted_directory_files(payload)?; let mut candidates = Vec::new(); + let has_manifest = |path: &Path| { + path.join("plugin.json").is_file() || path.join(".codex-plugin/plugin.json").is_file() + }; + let plugin_root = if has_manifest(payload) { + Some(payload.to_path_buf()) + } else { + let roots = fs::read_dir(payload) + .map_err(|_| "扩展来源不可读".to_string())? + .filter_map(Result::ok) + .map(|entry| entry.path()) + .filter(|path| path.is_dir() && has_manifest(path)) + .collect::>(); + if roots.len() > 1 { + return Err("请一次导入一个 Plugin 目录".to_string()); + } + roots.into_iter().next() + }; + let portable = plugin_root + .as_ref() + .is_some_and(|path| path.join("plugin.json").is_file()); + let mut prefix = String::new(); + if let Some(plugin_root) = plugin_root.as_ref() { + let relative_root = plugin_root + .strip_prefix(payload) + .map_err(|_| "Plugin 来源越界".to_string())?; + if !relative_root.as_os_str().is_empty() { + prefix = format!("{}/", normalize_relative_path(relative_root)?); + } + let manifest = crate::plugin_host::read_plugin_manifest(plugin_root)?; + candidates.push(ImportedCandidate { + extension_type: "plugin".to_string(), + original_name: manifest.id, + source_relative_path: format!( + "{prefix}{}", + if portable { + "plugin.json" + } else { + ".codex-plugin/plugin.json" + } + ), + fingerprint: fingerprint_directory(plugin_root)?, + mcp_config: None, + }); + } for (relative, path) in files { + if portable + && !(relative.starts_with(&format!("{prefix}skills/")) && is_skill_file(&path) + || relative == format!("{prefix}mcp.json")) + { + continue; + } if is_skill_file(&path) { candidates.push(ImportedCandidate { extension_type: "skill".to_string(), @@ -607,7 +690,7 @@ fn stored_item_view( "unknown" } else if item.last_error.is_some() { "startup-failed" - } else if item.enabled { + } else if extension_effectively_enabled(index, item) { "enabled" } else { "disabled" @@ -629,7 +712,7 @@ fn client_skill_set_fingerprint(index: &ClientExtensionIndex) -> String { let mut entries = index .items .iter() - .filter(|item| item.extension_type == "skill" && item.enabled) + .filter(|item| item.extension_type == "skill" && extension_effectively_enabled(index, item)) .map(|item| { ( item.name.clone(), @@ -655,7 +738,7 @@ fn client_mcp_set_fingerprint(index: &ClientExtensionIndex) -> String { let mut entries = index .items .iter() - .filter(|item| item.extension_type == "mcp" && item.enabled) + .filter(|item| item.extension_type == "mcp" && extension_effectively_enabled(index, item)) .map(|item| { ( item.id.clone(), @@ -1040,7 +1123,7 @@ fn prepare_client_skill_runtime_root( for item in index .items .iter() - .filter(|item| item.extension_type == "skill" && item.enabled) + .filter(|item| item.extension_type == "skill" && extension_effectively_enabled(index, item)) { let Some(source) = index .sources @@ -1087,7 +1170,9 @@ pub(crate) fn prepare_enabled_client_mcp_servers() -> Result Result { - let Some(item) = index + let parent_disabled = index .items - .iter_mut() - .find(|item| item.extension_type == "mcp" && item.enabled && item.id == extension_id) - else { + .iter() + .filter(|item| item.extension_type == "plugin" && !item.enabled) + .map(|item| item.source_id.clone()) + .collect::>(); + let Some(item) = index.items.iter_mut().find(|item| { + item.extension_type == "mcp" + && item.enabled + && !parent_disabled.contains(&item.source_id) + && item.id == extension_id + }) else { return Ok(false); }; let last_error = match status { @@ -1265,7 +1357,7 @@ pub(crate) fn list_client_extensions() -> Result, Strin list_client_extensions_at(&root) } -fn list_client_extensions_at(root: &Path) -> Result, String> { +pub(crate) fn list_client_extensions_at(root: &Path) -> Result, String> { read_client_extension_index_locked(&root, |_, index| { Ok(index .items @@ -1275,9 +1367,69 @@ fn list_client_extensions_at(root: &Path) -> Result, St }) } +pub(crate) fn client_plugin_sources_at(root: &Path) -> Result, String> { + read_client_extension_index_locked(root, |_, index| { + index + .items + .iter() + .filter(|item| item.extension_type == "plugin") + .map(|item| { + let source = index + .sources + .iter() + .find(|source| source.id == item.source_id) + .ok_or_else(|| "插件来源记录不存在".to_string())?; + normalize_relative_path(Path::new(&source.storage_path))?; + normalize_relative_path(Path::new(&item.source_relative_path))?; + let manifest_path = root + .join(&source.storage_path) + .join(&item.source_relative_path); + let manifest_parent = manifest_path + .parent() + .ok_or_else(|| "插件 manifest 路径无效".to_string())?; + let source_root = if item + .source_relative_path + .ends_with(".codex-plugin/plugin.json") + { + manifest_parent + .parent() + .ok_or_else(|| "插件根路径无效".to_string())? + .to_path_buf() + } else { + manifest_parent.to_path_buf() + }; + if !source_root + .canonicalize() + .map_err(|_| "插件来源目录不可读".to_string())? + .starts_with( + root.canonicalize() + .map_err(|_| "扩展目录不可读".to_string())?, + ) + { + return Err("插件来源目录越界".to_string()); + } + Ok(ClientPluginSource { + item: stored_item_view(index, item), + root: source_root, + }) + }) + .collect() + }) +} + +fn extension_effectively_enabled(index: &ClientExtensionIndex, item: &StoredExtensionItem) -> bool { + item.enabled + && !index.items.iter().any(|parent| { + parent.extension_type == "plugin" + && parent.source_id == item.source_id + && !parent.enabled + }) +} + #[tauri::command] pub(crate) fn import_client_extension( source_path: String, + host: tauri::State<'_, crate::plugin_host::PluginHost>, ) -> Result { let source = PathBuf::from(source_path.trim()); if source.as_os_str().is_empty() { @@ -1298,14 +1450,18 @@ pub(crate) fn import_client_extension( )?; let root = extensions_root()?; - import_client_extension_at(&root, &source, &metadata) + let result = import_client_extension_at(&root, &source, &metadata)?; + host.refresh()?; + Ok(result) } -fn import_client_extension_at( +pub(crate) fn import_client_extension_at( root: &Path, source: &Path, metadata: &fs::Metadata, ) -> Result { + fs::create_dir_all(root.join(CLIENT_EXTENSIONS_SOURCES_DIR_NAME)) + .map_err(|error| format!("准备扩展来源目录失败：{error}"))?; let source_id = new_id("source"); let source_display_name = source_name(&source); let source_storage_relative = format!("{}/{}", CLIENT_EXTENSIONS_SOURCES_DIR_NAME, source_id); @@ -1424,9 +1580,12 @@ fn import_client_extension_at( pub(crate) fn set_client_extension_enabled( id: String, enabled: bool, + host: tauri::State<'_, crate::plugin_host::PluginHost>, ) -> Result { let root = extensions_root()?; - set_client_extension_enabled_at(&root, &id, enabled) + let item = set_client_extension_enabled_at(&root, &id, enabled)?; + host.refresh()?; + Ok(item) } fn set_client_extension_enabled_at( @@ -1447,6 +1606,18 @@ fn set_client_extension_enabled_at( item.enabled = enabled; item.last_error = None; let view_item = item.clone(); + if view_item.extension_type == "plugin" { + let child_ids = index + .items + .iter() + .filter(|item| item.source_id == view_item.source_id) + .map(|item| item.id.as_str()) + .collect::>(); + client_mcp_connection_owners() + .lock() + .map_err(|_| "客户端 MCP 连接锁已损坏".to_string())? + .retain(|id, _| !child_ids.contains(id.as_str())); + } Ok((stored_item_view(index, &view_item), true)) }) } @@ -1455,6 +1626,7 @@ fn set_client_extension_enabled_at( pub(crate) fn rename_client_extension( id: String, name: String, + host: tauri::State<'_, crate::plugin_host::PluginHost>, ) -> Result { let requested = name.trim(); if requested.is_empty() { @@ -1462,7 +1634,9 @@ pub(crate) fn rename_client_extension( } let normalized = native_name(requested); let root = extensions_root()?; - rename_client_extension_at(&root, &id, &normalized) + let item = rename_client_extension_at(&root, &id, &normalized)?; + host.refresh()?; + Ok(item) } fn rename_client_extension_at( @@ -1513,9 +1687,14 @@ fn rename_client_extension_at( } #[tauri::command] -pub(crate) fn remove_client_extension(id: String) -> Result<(), String> { +pub(crate) fn remove_client_extension( + id: String, + host: tauri::State<'_, crate::plugin_host::PluginHost>, +) -> Result<(), String> { let root = extensions_root()?; - remove_client_extension_at(&root, &id) + remove_client_extension_at(&root, &id)?; + host.refresh()?; + Ok(()) } fn remove_client_extension_at(root: &Path, id: &str) -> Result<(), String> { @@ -1526,7 +1705,22 @@ fn remove_client_extension_at(root: &Path, id: &str) -> Result<(), String> { .iter() .position(|item| item.id == id.trim()) .ok_or_else(|| "未找到客户端扩展".to_string())?; - index.items.remove(item_index); + let removed = index.items.remove(item_index); + if removed.extension_type == "plugin" { + let child_ids = index + .items + .iter() + .filter(|item| item.source_id == removed.source_id) + .map(|item| item.id.clone()) + .collect::>(); + client_mcp_connection_owners() + .lock() + .map_err(|_| "客户端 MCP 连接锁已损坏".to_string())? + .retain(|id, _| !child_ids.contains(id)); + index + .items + .retain(|item| item.source_id != removed.source_id); + } Ok(((), true)) }) } @@ -2149,7 +2343,7 @@ mod tests { } #[test] - fn plugin_source_discovers_skill_and_mcp_as_independent_items() { + fn plugin_source_discovers_package_and_skill_and_mcp_items() { let fixture_root = PathBuf::from(env!("CARGO_MANIFEST_DIR")) .join("tests") .join("fixtures") @@ -2165,11 +2359,82 @@ mod tests { ) }) .collect::>(); - assert_eq!(candidates.len(), 2); + assert_eq!(candidates.len(), 3); + assert!(names.contains(&("plugin", "stage-0-fixture-plugin"))); assert!(names.contains(&("skill", "plugin-skill"))); assert!(names.contains(&("mcp", "plugin-search"))); } + #[test] + fn portable_plugin_parent_controls_component_injection_and_removal() { + let source = tempfile::tempdir().expect("plugin source"); + fs::create_dir_all(source.path().join("skills/help")).expect("skills"); + fs::write( + source.path().join("plugin.json"), + serde_json::json!({ + "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json", + "name": "portable-tools" + }) + .to_string(), + ) + .expect("manifest"); + fs::write( + source.path().join("skills/help/SKILL.md"), + "---\nname: help\ndescription: Help with the project.\n---\nRead the project.\n", + ) + .expect("skill"); + fs::write(source.path().join("mcp.json"), serde_json::json!({ + "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json", + "mcpServers": {"docs": {"type":"streamable-http", "url":"http://127.0.0.1:12345/mcp"}} + }).to_string()).expect("MCP config"); + let (_directory, root) = test_extension_root(); + let imported = import_client_extension_at( + &root, + source.path(), + &fs::metadata(source.path()).expect("metadata"), + ) + .expect("import"); + assert_eq!(imported.imported.len(), 3); + let parent = imported + .imported + .iter() + .find(|item| item.extension_type == "plugin") + .expect("parent"); + let index = read_index(&root).expect("index"); + let skill_fingerprint = client_skill_set_fingerprint(&index); + let mcp_fingerprint = client_mcp_set_fingerprint(&index); + set_client_extension_enabled_at(&root, &parent.id, false).expect("disable package"); + let disabled = read_index(&root).expect("disabled index"); + assert_ne!(client_skill_set_fingerprint(&disabled), skill_fingerprint); + assert_ne!(client_mcp_set_fingerprint(&disabled), mcp_fingerprint); + assert!(disabled + .items + .iter() + .filter(|item| item.extension_type != "plugin") + .all(|item| !extension_effectively_enabled(&disabled, item))); + set_client_extension_enabled_at(&root, &parent.id, true).expect("enable package"); + let enabled = read_index(&root).expect("enabled index"); + assert_eq!(client_skill_set_fingerprint(&enabled), skill_fingerprint); + remove_client_extension_at(&root, &parent.id).expect("remove package"); + assert!(read_index(&root).expect("remaining index").items.is_empty()); + } + + #[test] + fn portable_mcp_transport_must_match_connection_fields() { + let directory = tempfile::tempdir().expect("config directory"); + let path = directory.path().join("mcp.json"); + fs::write( + &path, + serde_json::json!({ + "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json", + "mcpServers": {"docs": {"type":"stdio", "url":"https://example.invalid/mcp"}} + }) + .to_string(), + ) + .expect("MCP config"); + assert!(parse_mcp_config_file(&path).is_err()); + } + #[test] fn fixture_directory_splits_independent_skill_and_mcp_items() { let fixture_root = PathBuf::from(env!("CARGO_MANIFEST_DIR")) diff --git a/apps/ai-game-creator-shell/src-tauri/src/commands.rs b/apps/ai-game-creator-shell/src-tauri/src/commands.rs index 9a370cfde..917014561 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/commands.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/commands.rs @@ -16,6 +16,10 @@ const AGENT_EDITOR_ASSET_LIBRARY_MAX_ITEMS: usize = 500; const AGENT_EDITOR_ASSET_ID_MAX_CHARS: usize = 512; const AUTOMATIC_PROJECT_NAME_MAX_PROMPT_CHARS: usize = 8_000; const AUTOMATIC_PROJECT_NAME_MAX_OUTPUT_TOKENS: u32 = 64; +// Project naming is an optional homepage enhancement. It must never hold the +// actual project creation flow behind the normal (potentially three-minute) +// generation timeout. +const AUTOMATIC_PROJECT_NAME_TIMEOUT_MS: u64 = 15_000; const AUTOMATIC_PROJECT_NAME_SYSTEM_PROMPT: &str = include_str!("../prompts/automatic-project-name.md"); @@ -55,11 +59,20 @@ async fn request_automatic_project_name(prompt: &str) -> Result, let user_prompt = build_automatic_project_name_prompt(prompt)?; let app_config = load_game_creator_app_config()?; if app_config.agent_mode == GAME_CREATOR_AGENT_MODE_CODEX_APP_SERVER { - let reply = crate::agent::direct_game_creator_home_codex_chat( - AUTOMATIC_PROJECT_NAME_SYSTEM_PROMPT.trim().to_string(), - user_prompt, + let reply = tokio::time::timeout( + std::time::Duration::from_millis(AUTOMATIC_PROJECT_NAME_TIMEOUT_MS), + crate::agent::direct_game_creator_home_codex_chat( + AUTOMATIC_PROJECT_NAME_SYSTEM_PROMPT.trim().to_string(), + user_prompt, + ), ) - .await?; + .await + .map_err(|_| { + format!( + "自动项目命名超时（超过 {} 秒）", + AUTOMATIC_PROJECT_NAME_TIMEOUT_MS / 1_000 + ) + })??; return Ok(normalize_suggested_project_name(reply.trim())); } let mut llm = app_config.llm.clone(); @@ -72,10 +85,18 @@ async fn request_automatic_project_name(prompt: &str) -> Result, .with_request_timeout_ms(llm.request_timeout_ms) .with_max_output_tokens(AUTOMATIC_PROJECT_NAME_MAX_OUTPUT_TOKENS) .with_web_search(false); - let response = client - .run(request) - .await - .map_err(|error| format!("自动项目命名失败：{error}"))?; + let response = tokio::time::timeout( + std::time::Duration::from_millis(AUTOMATIC_PROJECT_NAME_TIMEOUT_MS), + client.run(request), + ) + .await + .map_err(|_| { + format!( + "自动项目命名超时（超过 {} 秒）", + AUTOMATIC_PROJECT_NAME_TIMEOUT_MS / 1_000 + ) + })? + .map_err(|error| format!("自动项目命名失败：{error}"))?; Ok(normalize_suggested_project_name(response.text.trim())) } @@ -320,13 +341,19 @@ pub(crate) fn closest_existing_project_picker_directory(path: &Path) -> Option

Result { app.path() - .document_dir() - .map(|documents_root| documents_root.join(AUTOMATIC_PROJECTS_DIRECTORY_NAME)) - .map_err(|error| format!("无法读取系统文档目录：{error}")) + .app_data_dir() + .map(|app_data_root| { + // Automatic workspaces are AGC-managed data. Keeping them below + // the hardened per-user app-data root avoids applying the strict + // private-DACL gate to a user Documents directory whose inherited + // ACL AGC is not allowed to rewrite. + app_data_root.join(AUTOMATIC_PROJECTS_DIRECTORY_NAME) + }) + .map_err(|error| format!("无法读取 AGC 应用数据目录：{error}")) } pub(crate) fn create_automatic_local_game_project_at( @@ -471,6 +498,24 @@ pub(crate) fn import_local_godot_project( import_local_godot_project_at(root, project_id.trim(), name.trim()) } +#[tauri::command] +pub(crate) fn import_local_cocos_project( + project_path: String, + project_id: String, + name: String, +) -> Result { + let root = Path::new(project_path.trim()); + enforce_project_permission_policy(root, "project.create")?; + if discover_local_cocos_project_root(root)?.is_none() { + return Err( + "所选目录不是有效的 Cocos Creator 项目（需要 package.json.creator.version 和 assets/）" + .to_string(), + ); + } + let _lock = acquire_project_write_lock(root, "project.create")?; + import_local_cocos_project_at(root, project_id.trim(), name.trim()) +} + #[tauri::command] pub(crate) fn is_local_project_directory_non_empty(project_path: String) -> Result { let root = Path::new(project_path.trim()); @@ -499,7 +544,15 @@ pub(crate) fn is_local_project_directory_non_empty(project_path: String) -> Resu } #[tauri::command] -pub(crate) fn inspect_local_project_directory( +pub(crate) async fn inspect_local_project_directory( + project_path: String, +) -> Result { + tauri::async_runtime::spawn_blocking(move || inspect_local_project_directory_sync(project_path)) + .await + .map_err(|error| format!("检查项目目录后台任务失败：{error}"))? +} + +pub(crate) fn inspect_local_project_directory_sync( project_path: String, ) -> Result { let root = Path::new(project_path.trim()); @@ -523,6 +576,7 @@ pub(crate) fn inspect_local_project_directory( } let recent_run_trace = recent_game_creator_run_trace(root); let godot_project_root = discover_local_godot_project_root(root)?; + let cocos_project_root = discover_local_cocos_project_root(root)?; Ok(LocalProjectDirectoryStatus { project_path: root.to_string_lossy().into_owned(), exists: root.exists(), @@ -530,6 +584,8 @@ pub(crate) fn inspect_local_project_directory( is_game_creator_project: is_game_creator_project_directory(root), is_godot_project: godot_project_root.is_some(), godot_project_root, + is_cocos_project: cocos_project_root.is_some(), + cocos_project_root, project_name: game_creator_project_name(root), modified_at: project_directory_modified_at(root), manifest_error: game_creator_project_manifest_error(root), @@ -800,7 +856,18 @@ mod plan_gdd_markdown_path_tests { } #[tauri::command] -pub(crate) fn get_local_game_manifest( +pub(crate) async fn get_local_game_manifest( + project_path: String, + command_id: Option, +) -> Result { + tauri::async_runtime::spawn_blocking(move || { + get_local_game_manifest_sync(project_path, command_id) + }) + .await + .map_err(|error| format!("读取项目 manifest 后台任务失败：{error}"))? +} + +pub(crate) fn get_local_game_manifest_sync( project_path: String, command_id: Option, ) -> Result { @@ -4700,23 +4767,31 @@ pub(crate) fn archive_game_creator_agent_session( } #[tauri::command] -pub(crate) fn read_local_conversation( +pub(crate) async fn read_local_conversation( project_path: String, agent_id: Option, session_id: Option, ) -> Result { - let root = Path::new(project_path.trim()); - enforce_project_permission_policy(root, "conversation.read")?; - read_local_conversation_for_session_at(root, agent_id.as_deref(), session_id.as_deref()) + tauri::async_runtime::spawn_blocking(move || { + let root = Path::new(project_path.trim()); + enforce_project_permission_policy(root, "conversation.read")?; + read_local_conversation_for_session_at(root, agent_id.as_deref(), session_id.as_deref()) + }) + .await + .map_err(|error| format!("读取项目对话后台任务失败：{error}"))? } #[tauri::command] -pub(crate) fn read_direct_project_conversation( +pub(crate) async fn read_direct_project_conversation( project_path: String, ) -> Result { - let root = Path::new(project_path.trim()); - enforce_project_permission_policy(root, "conversation.read")?; - read_direct_project_chat_history_at(root) + tauri::async_runtime::spawn_blocking(move || { + let root = Path::new(project_path.trim()); + enforce_project_permission_policy(root, "conversation.read")?; + read_direct_project_chat_history_at(root) + }) + .await + .map_err(|error| format!("读取 DirectProject 历史后台任务失败：{error}"))? } #[tauri::command] diff --git a/apps/ai-game-creator-shell/src-tauri/src/editor_adapter/mod.rs b/apps/ai-game-creator-shell/src-tauri/src/editor_adapter/mod.rs new file mode 100644 index 000000000..c3c384ada --- /dev/null +++ b/apps/ai-game-creator-shell/src-tauri/src/editor_adapter/mod.rs @@ -0,0 +1,8 @@ +//! Editor adapters used by the generic AGC plugin host. +//! +//! The host owns plugin lifecycle, RPC, permissions and auditing. Adapters +//! only know how to find and talk to a particular editor, and ship inside the +//! plugin package they belong to under the `plugins/` workspace. This module +//! only re-exports the shared contract so the host stays editor-agnostic. + +pub(crate) use editor_adapter_api::{EditorAdapter, EditorConnectionInfo}; diff --git a/apps/ai-game-creator-shell/src-tauri/src/editor_adapters.rs b/apps/ai-game-creator-shell/src-tauri/src/editor_adapters.rs new file mode 100644 index 000000000..ba2949e8b --- /dev/null +++ b/apps/ai-game-creator-shell/src-tauri/src/editor_adapters.rs @@ -0,0 +1,54 @@ +//! 已链接的编辑器适配器目录。 +//! +//! 编辑器专属实现随 `plugins/` 工作区里的插件包分发；其中 native 适配器模块 +//! 目前由宿主在编译期链接（Cargo path 依赖），再按插件 manifest 的 `adapter` +//! 字段注册到通用插件宿主。宿主只认适配器 id，不包含目标编辑器知识。 + +#[cfg(feature = "cocos-editor")] +use std::path::PathBuf; + +#[cfg(feature = "cocos-editor")] +use tauri::Manager; + +use crate::plugin_host::PluginHost; + +/// 随包 payload 相对资源根目录的位置，与 `tauri.windows.conf.json` 的资源映射保持一致。 +#[allow(dead_code)] +pub(crate) const COCOS_BRIDGE_PAYLOAD_RELATIVE: &str = + "plugins/agc-cocos-editor/native/payload/cocos-editor-bridge.dll"; + +pub(crate) fn register_linked_editor_adapters( + app: &tauri::AppHandle, + host: &PluginHost, +) -> Result<(), String> { + #[cfg(feature = "cocos-editor")] + { + let adapter = + cocos_editor_bridge::CocosEditorAdapter::new(cocos_bridge_payload_candidates(app)); + host.register_editor_adapter(Box::new(adapter))?; + } + #[cfg(not(feature = "cocos-editor"))] + { + let _ = (app, host); + } + Ok(()) +} + +#[cfg(feature = "cocos-editor")] +fn cocos_bridge_payload_candidates(app: &tauri::AppHandle) -> Vec { + let mut candidates = Vec::new(); + if let Ok(resource_dir) = app.path().resource_dir() { + candidates.push(resource_dir.join(COCOS_BRIDGE_PAYLOAD_RELATIVE)); + } + // 开发构建还要能直接从 plugins/ 工作区读取尚未打包的 payload。 + #[cfg(debug_assertions)] + { + let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")); + candidates.push( + manifest_dir + .join("../../../plugins/agc-cocos-editor/native/payload") + .join("cocos-editor-bridge.dll"), + ); + } + candidates +} diff --git a/apps/ai-game-creator-shell/src-tauri/src/isolated_agent.rs b/apps/ai-game-creator-shell/src-tauri/src/isolated_agent.rs index 22b04c37b..2e267b28f 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/isolated_agent.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/isolated_agent.rs @@ -43,6 +43,7 @@ pub(crate) const ISOLATED_AGENT_UNSCOPED_DENIED_COMMAND_IDS: &[&str] = &[ "command.exec", "command.start", "command.stdin", + "cocos.editor.execute", "preview.start", "agent.delegate", "agent.spawn_isolated", @@ -62,6 +63,7 @@ pub(crate) const ISOLATED_AGENT_UNSCOPED_DENIED_TOOLS: &[&str] = &[ "command.exec", "command.start", "command.stdin", + "cocos.editor.execute", "preview.start", "agent.delegate", "agent.spawn_isolated", diff --git a/apps/ai-game-creator-shell/src-tauri/src/main.rs b/apps/ai-game-creator-shell/src-tauri/src/main.rs index 8fc62362c..68d09633b 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/main.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/main.rs @@ -244,6 +244,7 @@ mod agent; mod agent_native_tools; mod assets; mod browser; +mod builtin_plugins; mod cli; mod client_extensions; mod collaboration; @@ -258,6 +259,8 @@ mod context_menu; #[cfg(all(debug_assertions, not(test)))] mod debug; mod delegation; +mod editor_adapter; +mod editor_adapters; pub mod error_report; mod git_inspect; mod goal; @@ -266,6 +269,7 @@ mod image_inspect; mod isolated_agent; mod patchset; mod platform_session; +mod plugin_host; mod preview; mod process_session; mod process_session_bridge; @@ -302,6 +306,11 @@ use image_inspect::*; use isolated_agent::*; use patchset::*; use platform_session::*; +use plugin_host::{ + call_agc_plugin, list_agc_extensions, list_agc_plugins, read_agc_plugin_panel, + refresh_agc_plugins, reload_agc_plugin, set_agc_plugin_enabled, set_agc_plugin_project_path, + start_agc_plugin, stop_agc_plugin, PluginHost, +}; use preview::*; use process_session::*; use project::*; @@ -393,6 +402,8 @@ struct LocalProjectDirectoryStatus { is_game_creator_project: bool, is_godot_project: bool, godot_project_root: Option, + is_cocos_project: bool, + cocos_project_root: Option, project_name: Option, modified_at: Option, manifest_error: Option, @@ -2469,6 +2480,7 @@ fn main() { .plugin(context_menu::init()) .manage(game_creator_preview_registry()) .manage(ProjectResourcePreviewReadManager::default()) + .manage(PluginHost::default()) .setup(move |app| { error_report::initialize_notifications(app.handle()); setup_log.append("startup.setup.begin"); @@ -2494,6 +2506,23 @@ fn main() { setup_log.fail("startup.appdata.resolve.failed details=config-dir-uninitialized"); error })?; + if let Err(error) = builtin_plugins::initialize(&config_dir) { + app_log!("startup.builtin-plugins.initialize.failed: {error}"); + } + if let Err(error) = app.state::().initialize(&config_dir) { + app_log!("startup.plugin-host.initialize.failed: {error}"); + } + if let Some(workspace) = plugin_host::resolve_plugin_workspace(app.handle()) { + if let Err(error) = app.state::().set_plugin_workspace(workspace) { + app_log!("startup.plugin-host.workspace.failed: {error}"); + } + } + if let Err(error) = editor_adapters::register_linked_editor_adapters( + app.handle(), + app.state::().inner(), + ) { + app_log!("startup.plugin-host.adapter.failed: {error}"); + } load_platform_session_fixture_from_env(&config_dir).map_err(|error| { std::io::Error::new( std::io::ErrorKind::PermissionDenied, @@ -2557,6 +2586,7 @@ fn main() { create_automatic_local_game_project, init_local_game_project, import_local_godot_project, + import_local_cocos_project, is_local_project_directory_non_empty, inspect_local_project_directory, pick_local_project_directory, @@ -2570,6 +2600,16 @@ fn main() { set_client_extension_enabled, rename_client_extension, remove_client_extension, + list_agc_plugins, + list_agc_extensions, + refresh_agc_plugins, + start_agc_plugin, + stop_agc_plugin, + reload_agc_plugin, + set_agc_plugin_enabled, + call_agc_plugin, + read_agc_plugin_panel, + set_agc_plugin_project_path, open_local_project_directory, open_local_project_plan_gdd_markdown, control_agent_run, @@ -2717,7 +2757,7 @@ fn main() { read_diagnostic_logs, report_client_error, get_pending_error_reports, - ack_error_reports + ack_error_reports, ]) .build(tauri_context); let app = match app { diff --git a/apps/ai-game-creator-shell/src-tauri/src/plugin_host.rs b/apps/ai-game-creator-shell/src-tauri/src/plugin_host.rs new file mode 100644 index 000000000..5513aa6e3 --- /dev/null +++ b/apps/ai-game-creator-shell/src-tauri/src/plugin_host.rs @@ -0,0 +1,2111 @@ +//! Generic AGC plugin host. +//! +//! This module deliberately contains no target-editor knowledge. Plugin +//! discovery, manifest validation, process lifecycle, JSON-RPC, UI/capability +//! registration, permission checks and audit records are shared by every +//! editor. Target-specific work is delegated to `editor_adapter`. + +use std::collections::{BTreeMap, BTreeSet}; +use std::fs; +use std::io::{BufRead, BufReader, Write}; +use std::path::{Component, Path, PathBuf}; +use std::process::{Child, ChildStdin, Command, Stdio}; +use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender}; +use std::sync::Arc; +use std::sync::Mutex; +use std::thread; +use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; + +use serde::{Deserialize, Serialize}; +use serde_json::{json, Value}; +use tauri::{Manager, State}; + +use crate::editor_adapter::{EditorAdapter, EditorConnectionInfo}; + +type EditorRegistry = Arc>>>; +type ProjectContext = Arc>>; +type PendingRpc = Arc>>>>; + +const PLUGIN_MANIFEST_FILE_NAME: &str = "plugin.json"; +const PLUGIN_MANIFEST_FALLBACK: &str = ".codex-plugin/plugin.json"; +const AGENT_PLUGINS_SCHEMA: &str = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json"; +const AGC_EXTENSION_NAMESPACE: &str = "world.genarrative.agc"; +const PLUGIN_PROTOCOL_VERSION: &str = "agc.plugin.v1"; +const PLUGIN_API_VERSION: &str = "v1"; +const AUDIT_FILE_NAME: &str = "audit.jsonl"; +const RPC_TIMEOUT: Duration = Duration::from_secs(10); +// 编辑器连接可包含受控引导；外层必须覆盖引导和编辑器命令的完整期限。 +const EDITOR_RPC_TIMEOUT: Duration = Duration::from_secs(90); +const MAX_MANIFEST_BYTES: u64 = 1024 * 1024; +const MAX_RPC_BYTES: usize = 2 * 1024 * 1024; + +const KNOWN_PERMISSIONS: &[&str] = &[ + "events.subscribe", + "project.read", + "editor.rpc", + "ui.register", + "capability.register", +]; + +#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct PluginPanelManifest { + pub(crate) id: String, + pub(crate) title: String, + pub(crate) entry: String, + #[serde(default)] + pub(crate) placement: Option, +} + +#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct PluginManifest { + pub(crate) id: String, + pub(crate) name: String, + pub(crate) version: String, + #[serde(default = "default_api_version")] + pub(crate) api_version: String, + pub(crate) entry: Option, + #[serde(default)] + pub(crate) permissions: BTreeSet, + #[serde(default = "default_enabled")] + pub(crate) enabled: bool, + #[serde(default)] + pub(crate) adapter: Option, + #[serde(default)] + pub(crate) panels: Vec, +} + +fn default_api_version() -> String { + PLUGIN_API_VERSION.to_string() +} + +fn default_enabled() -> bool { + true +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct PluginCommandDescriptor { + pub(crate) id: String, + pub(crate) title: String, + pub(crate) description: Option, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct PluginPanelDescriptor { + pub(crate) id: String, + pub(crate) title: String, + pub(crate) entry: String, + pub(crate) placement: Option, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct PluginCapabilityDescriptor { + pub(crate) id: String, + pub(crate) description: Option, +} + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct PluginPanelContent { + panel: PluginPanelDescriptor, + html: String, +} + +#[derive(Clone, Debug, Eq, PartialEq, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct PluginSummary { + pub(crate) id: String, + pub(crate) name: String, + pub(crate) version: String, + pub(crate) api_version: String, + pub(crate) enabled: bool, + /// 内置插件随包分发，不能卸载，只能通过可用开关启停。 + pub(crate) builtin: bool, + pub(crate) has_runtime: bool, + pub(crate) status: String, + pub(crate) adapter: Option, + pub(crate) permissions: Vec, + pub(crate) commands: Vec, + pub(crate) panels: Vec, + pub(crate) capabilities: Vec, + pub(crate) last_error: Option, +} + +/// Unified catalog entry. Skills and MCPs keep their existing runtime +/// adapters, while executable plugins use this host's lifecycle and RPC. +#[derive(Clone, Debug, Serialize)] +#[serde(rename_all = "camelCase")] +pub(crate) struct AgcExtensionSummary { + pub(crate) kind: String, + pub(crate) id: String, + pub(crate) name: String, + pub(crate) enabled: bool, + pub(crate) builtin: bool, + pub(crate) status: String, + pub(crate) plugin: Option, + pub(crate) client_extension: Option, +} + +struct RunningPlugin { + child: Child, + #[cfg(windows)] + _job: crate::process_session::WindowsProcessJob, + stdin: Arc>, + lines: Option>, + pending: PendingRpc, + registrations: Arc>, + next_request_id: u64, +} + +impl Drop for RunningPlugin { + fn drop(&mut self) { + #[cfg(unix)] + unsafe { + libc::kill(-(self.child.id() as i32), libc::SIGKILL); + } + let _ = self.child.kill(); + let _ = self.child.wait(); + } +} + +#[derive(Default)] +struct PluginRegistrations { + commands: BTreeMap, + panels: BTreeMap, + capabilities: BTreeMap, + subscriptions: BTreeMap, +} + +#[derive(Default)] +struct PluginRegistrationsSnapshot { + commands: Vec, + panels: Vec, + capabilities: Vec, +} + +fn register_entry( + entries: &mut BTreeMap, + id: String, + entry: T, +) -> Result<(), String> { + if entries.len() >= 128 || entries.contains_key(&id) { + return Err("插件注册项重复或超过数量限制".to_string()); + } + entries.insert(id, entry); + Ok(()) +} + +struct PluginRecord { + id: String, + manifest: PluginManifest, + root: PathBuf, + status: String, + last_error: Option, + running: Option, +} + +#[derive(Default)] +struct PluginHostState { + root: Option, + workspace: Option, + plugins: BTreeMap, + active_project: ProjectContext, + editors: EditorRegistry, +} + +#[derive(Default)] +pub(crate) struct PluginHost { + state: Mutex, +} + +#[derive(Debug, Deserialize)] +struct RpcEnvelope { + #[serde(default)] + jsonrpc: Option, + #[serde(default)] + id: Option, + #[serde(default)] + method: Option, + #[serde(default)] + params: Option, + #[serde(default, deserialize_with = "deserialize_rpc_result")] + result: Option, + #[serde(default)] + error: Option, +} + +fn deserialize_rpc_result<'de, D: serde::Deserializer<'de>>( + deserializer: D, +) -> Result, D::Error> { + Value::deserialize(deserializer).map(Some) +} + +fn valid_identifier(value: &str) -> bool { + let mut chars = value.chars(); + matches!(chars.next(), Some(c) if c.is_ascii_lowercase() || c.is_ascii_digit()) + && value.len() <= 64 + && value + .chars() + .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || matches!(c, '-' | '_' | '.')) +} + +fn valid_text(value: &str, max: usize) -> bool { + let trimmed = value.trim(); + !trimmed.is_empty() && trimmed.len() <= max && !trimmed.chars().any(char::is_control) +} + +fn validate_relative_path(value: &str) -> Result<(), String> { + let path = Path::new(value.strip_prefix("./").unwrap_or(value)); + if value.trim().is_empty() + || value.len() > 1024 + || value.chars().any(char::is_control) + || value.contains(['\\', ':']) + || path.is_absolute() + { + return Err("插件入口必须是相对路径".to_string()); + } + if path + .components() + .any(|component| !matches!(component, Component::Normal(_))) + { + return Err("插件入口不能包含越界或特殊路径".to_string()); + } + Ok(()) +} + +fn project_read_path(project: &Path, relative: &str) -> Result { + validate_relative_path(relative)?; + let canonical_project = project + .canonicalize() + .map_err(|_| "当前项目不可读".to_string())?; + let mut candidate = canonical_project.clone(); + for component in Path::new(relative).components() { + let Component::Normal(name) = component else { + return Err("项目文件路径无效".to_string()); + }; + let name_text = name.to_string_lossy().to_ascii_lowercase(); + if matches!( + name_text.as_str(), + ".agent" | ".agents" | ".codex" | ".git" | ".env" + ) || name_text.starts_with(".env.") + { + return Err("插件不能读取项目控制或凭据目录".to_string()); + } + candidate.push(name); + let metadata = + fs::symlink_metadata(&candidate).map_err(|_| "项目文件不可读".to_string())?; + if metadata.file_type().is_symlink() { + return Err("插件不能读取符号链接".to_string()); + } + #[cfg(windows)] + { + use std::os::windows::fs::MetadataExt; + if metadata.file_attributes() & 0x400 != 0 { + return Err("插件不能读取重解析点".to_string()); + } + } + } + let canonical = candidate + .canonicalize() + .map_err(|_| "项目文件不可读".to_string())?; + if !canonical.starts_with(&canonical_project) { + return Err("插件文件读取越出项目目录".to_string()); + } + Ok(canonical) +} + +pub(crate) fn validate_manifest(manifest: &PluginManifest) -> Result<(), String> { + if !valid_identifier(&manifest.id) { + return Err("插件 id 必须使用小写字母、数字、点、短横线或下划线".to_string()); + } + if !valid_text(&manifest.name, 80) || !valid_text(&manifest.version, 32) { + return Err("插件名称或版本无效".to_string()); + } + if manifest.api_version != PLUGIN_API_VERSION { + return Err(format!("不支持的插件 API 版本：{}", manifest.api_version)); + } + if let Some(entry) = manifest.entry.as_deref() { + validate_relative_path(entry)?; + } + if manifest + .permissions + .iter() + .any(|permission| !KNOWN_PERMISSIONS.contains(&permission.as_str())) + { + return Err("插件声明了未知权限".to_string()); + } + if let Some(adapter) = &manifest.adapter { + if !valid_identifier(adapter) { + return Err("编辑器适配器标识无效".to_string()); + } + } + let mut panel_ids = BTreeSet::new(); + for panel in &manifest.panels { + if !valid_identifier(&panel.id) + || !valid_text(&panel.title, 80) + || !panel_ids.insert(panel.id.clone()) + { + return Err("插件面板声明无效或存在重复 id".to_string()); + } + validate_relative_path(&panel.entry)?; + } + Ok(()) +} + +fn manifest_path(root: &Path) -> Option { + for candidate in [PLUGIN_MANIFEST_FILE_NAME, PLUGIN_MANIFEST_FALLBACK] { + let path = root.join(candidate); + if path.is_file() { + return Some(path); + } + } + None +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +struct RawPluginManifest { + #[serde(rename = "$schema")] + schema: Option, + name: String, + #[serde(default)] + version: Option, + #[serde(default)] + extensions: BTreeMap, +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +struct AgcRuntimeExtension { + #[serde(default)] + api_version: Option, + #[serde(default)] + entry: Option, + #[serde(default)] + permissions: BTreeSet, + #[serde(default = "default_enabled")] + enabled: bool, + #[serde(default)] + adapter: Option, + #[serde(default)] + panels: Vec, +} + +pub(crate) fn read_plugin_manifest(root: &Path) -> Result { + let path = manifest_path(root).ok_or_else(|| "缺少 plugin.json manifest".to_string())?; + let metadata = + fs::symlink_metadata(&path).map_err(|error| format!("读取插件 manifest 失败：{error}"))?; + if metadata.file_type().is_symlink() + || !metadata.is_file() + || metadata.len() > MAX_MANIFEST_BYTES + { + return Err("插件 manifest 必须是受限的普通文件".to_string()); + } + let bytes = fs::read(&path).map_err(|error| format!("读取插件 manifest 失败：{error}"))?; + let raw = serde_json::from_slice::(&bytes) + .map_err(|error| format!("解析插件 manifest 失败：{error}"))?; + if path == root.join(PLUGIN_MANIFEST_FILE_NAME) + && raw.schema.as_deref() != Some(AGENT_PLUGINS_SCHEMA) + { + return Err("不支持的 Agent Plugins schema".to_string()); + } + if path == root.join(PLUGIN_MANIFEST_FILE_NAME) + && raw.name.split('-').any(|part| { + part.is_empty() + || !part + .chars() + .all(|character| character.is_ascii_lowercase() || character.is_ascii_digit()) + }) + { + return Err("Agent Plugin name 必须使用 kebab-case".to_string()); + } + let runtime = serde_json::from_value::( + raw.extensions + .get(AGC_EXTENSION_NAMESPACE) + .cloned() + .unwrap_or_else(|| json!({})), + ) + .map_err(|error| format!("AGC 插件运行扩展无效：{error}"))?; + let display_name = raw + .extensions + .get("com.openai") + .and_then(|extension| extension.get("interface")) + .and_then(|interface| interface.get("displayName")) + .and_then(Value::as_str) + .unwrap_or(&raw.name) + .to_string(); + let manifest = PluginManifest { + id: raw.name, + name: display_name, + version: raw.version.unwrap_or_else(|| "0.0.0".to_string()), + api_version: runtime.api_version.unwrap_or_else(default_api_version), + entry: runtime.entry, + permissions: runtime.permissions, + enabled: runtime.enabled, + adapter: runtime.adapter, + panels: runtime.panels, + }; + validate_manifest(&manifest)?; + if let Some(entry) = manifest.entry.as_deref() { + let entry = project_read_path(root, entry.strip_prefix("./").unwrap_or(entry))?; + let metadata = + fs::symlink_metadata(&entry).map_err(|error| format!("插件入口不可读：{error}"))?; + if metadata.file_type().is_symlink() || !metadata.is_file() { + return Err("插件入口必须是普通文件".to_string()); + } + } + Ok(manifest) +} + +fn plugin_root(config_dir: &Path) -> Result { + let root = config_dir.join("extensions"); + fs::create_dir_all(&root).map_err(|error| format!("准备插件目录失败：{error}"))?; + Ok(root) +} + +/// 解析插件工作区目录：环境变量优先，其次随包资源目录 `plugins/`， +/// 开发构建再回退仓库里的 `plugins/` 工作区。 +pub(crate) fn resolve_plugin_workspace(app: &tauri::AppHandle) -> Option { + if let Some(workspace) = std::env::var_os("AGC_PLUGIN_WORKSPACE") { + let workspace = PathBuf::from(workspace); + if workspace.is_dir() { + return Some(workspace); + } + } + if let Ok(resource_dir) = app.path().resource_dir() { + let bundled = resource_dir.join("plugins"); + if bundled.is_dir() { + return Some(bundled); + } + } + #[cfg(debug_assertions)] + { + let repo_root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../.."); + let workspace = repo_root.join("plugins"); + if workspace.is_dir() { + return Some(workspace); + } + } + None +} + +/// 统一后的插件来源，屏蔽“AppData 导入”和“plugins/ 工作区”的差别。 +#[derive(Clone, Debug)] +struct ScannedPluginSource { + id: String, + name: String, + original_name: String, + /// `Some` 表示启用状态由来源索引决定；`None` 表示沿用插件 manifest 声明。 + enabled: Option, + root: PathBuf, +} + +impl ScannedPluginSource { + fn from_imported(source: crate::client_extensions::ClientPluginSource) -> Self { + Self { + id: source.item.id, + name: source.item.name, + original_name: source.item.original_name, + enabled: Some(source.item.enabled), + root: source.root, + } + } +} + +/// 扫描 `plugins/` 工作区：每个含根目录 `plugin.json` 的子目录是一个插件包。 +/// +/// 工作区插件随包分发：内置插件按用户可用开关决定启用状态，其它工作区插件 +/// 沿用 manifest 声明。 +fn workspace_plugin_sources(root: &Path) -> Result, String> { + let entries = match fs::read_dir(root) { + Ok(entries) => entries, + Err(error) => return Err(format!("读取插件工作区失败：{error}")), + }; + let mut sources = Vec::new(); + for entry in entries.flatten() { + let plugin_root = entry.path(); + if !plugin_root.is_dir() || !plugin_root.join(PLUGIN_MANIFEST_FILE_NAME).is_file() { + continue; + } + let id = entry.file_name().to_string_lossy().into_owned(); + let enabled = crate::builtin_plugins::toggle_state(&id); + sources.push(ScannedPluginSource { + id: id.clone(), + name: id.clone(), + original_name: id, + enabled, + root: plugin_root, + }); + } + sources.sort_by(|left, right| left.id.cmp(&right.id)); + Ok(sources) +} + +fn audit_path(root: &Path) -> PathBuf { + root.join(AUDIT_FILE_NAME) +} + +fn audit(root: &Path, plugin_id: &str, action: &str, allowed: bool, reason: Option<&str>) { + let timestamp = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|value| value.as_millis()) + .unwrap_or_default(); + let record = json!({ + "schemaVersion": PLUGIN_PROTOCOL_VERSION, + "timestamp": timestamp, + "pluginId": plugin_id, + "action": action, + "allowed": allowed, + "reason": reason, + }); + let _ = crate::append_bounded_diagnostic_line(&audit_path(root), &record.to_string()); +} + +fn spawn_plugin(manifest: &PluginManifest, root: &Path) -> Result { + let entry = root.join( + manifest + .entry + .as_deref() + .ok_or_else(|| "该 Plugin 只包含 Skill/MCP，不能作为进程启动".to_string())?, + ); + let mut command = if matches!( + entry.extension().and_then(|value| value.to_str()), + Some("js" | "mjs" | "cjs") + ) { + let mut command = Command::new("node"); + command.arg(&entry); + command + } else { + Command::new(&entry) + }; + command + .env_clear() + .current_dir(root) + .env("AGC_PLUGIN_ID", &manifest.id) + .env("AGC_PLUGIN_PROTOCOL", PLUGIN_PROTOCOL_VERSION) + .env("AGC_PLUGIN_API_VERSION", &manifest.api_version) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::null()); + for variable in [ + "PATH", + "SystemRoot", + "WINDIR", + "SystemDrive", + "ComSpec", + "TEMP", + "TMP", + "PATHEXT", + ] { + if let Some(value) = std::env::var_os(variable) { + command.env(variable, value); + } + } + #[cfg(windows)] + { + use std::os::windows::process::CommandExt; + command.creation_flags(0x0800_0000); + } + #[cfg(unix)] + { + use std::os::unix::process::CommandExt; + command.process_group(0); + } + let mut child = command + .spawn() + .map_err(|error| format!("启动插件失败：{error}"))?; + #[cfg(windows)] + let job = match crate::process_session::WindowsProcessJob::assign_std(&child) { + Ok(job) => job, + Err(error) => { + let _ = child.kill(); + let _ = child.wait(); + return Err(error); + } + }; + let stdin = Arc::new(Mutex::new( + child + .stdin + .take() + .ok_or_else(|| "插件 stdin 不可用".to_string())?, + )); + let stdout = child + .stdout + .take() + .ok_or_else(|| "插件 stdout 不可用".to_string())?; + let (sender, receiver) = mpsc::sync_channel(16); + thread::spawn(move || { + let mut reader = BufReader::new(stdout); + while let Ok(Some(line)) = read_bounded_rpc_line(&mut reader) { + if sender.send(line).is_err() { + break; + } + } + }); + Ok(RunningPlugin { + child, + #[cfg(windows)] + _job: job, + stdin, + lines: Some(receiver), + pending: Arc::new(Mutex::new(BTreeMap::new())), + registrations: Arc::new(Mutex::new(PluginRegistrations::default())), + next_request_id: 1, + }) +} + +fn read_bounded_rpc_line(reader: &mut impl BufRead) -> Result, String> { + let mut bytes = Vec::new(); + loop { + let buffer = reader + .fill_buf() + .map_err(|_| "读取插件输出失败".to_string())?; + if buffer.is_empty() { + return if bytes.is_empty() { + Ok(None) + } else { + Err("插件输出缺少换行".to_string()) + }; + } + let newline = buffer.iter().position(|byte| *byte == b'\n'); + let count = newline.map_or(buffer.len(), |index| index + 1); + if bytes.len() + count > MAX_RPC_BYTES { + return Err("插件输出超过大小限制".to_string()); + } + bytes.extend_from_slice(&buffer[..count]); + reader.consume(count); + if newline.is_some() { + return String::from_utf8(bytes) + .map(Some) + .map_err(|_| "插件输出不是 UTF-8".to_string()); + } + } +} + +fn write_rpc(stdin: &mut ChildStdin, value: &Value) -> Result<(), String> { + let payload = + serde_json::to_string(value).map_err(|error| format!("序列化插件 RPC 失败：{error}"))?; + if payload.len() > MAX_RPC_BYTES { + return Err("插件 RPC 请求过大".to_string()); + } + writeln!(stdin, "{payload}").map_err(|error| format!("写入插件 RPC 失败：{error}"))?; + stdin + .flush() + .map_err(|error| format!("刷新插件 RPC 失败：{error}")) +} + +fn write_rpc_shared(stdin: &Arc>, value: &Value) -> Result<(), String> { + let mut stdin = stdin + .lock() + .map_err(|_| "插件 stdin 锁已损坏".to_string())?; + write_rpc(&mut stdin, value) +} + +fn descriptor_from_params Deserialize<'de>>( + params: Option, +) -> Result { + serde_json::from_value(params.unwrap_or_else(|| json!({}))) + .map_err(|error| format!("插件注册参数无效：{error}")) +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +struct RegisterCommandInput { + id: String, + title: String, + #[serde(default)] + description: Option, +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +struct RegisterPanelInput { + id: String, + title: String, + entry: String, + #[serde(default)] + placement: Option, +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +struct RegisterCapabilityInput { + id: String, + #[serde(default)] + description: Option, +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +struct ProjectReadInput { + path: String, +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +struct EditorRpcInput { + #[serde(default)] + adapter: Option, + method: String, + #[serde(default)] + params: Value, +} + +fn permission_for_method(method: &str) -> Option<&'static str> { + match method { + "host.project.read" => Some("project.read"), + "host.rpc" => Some("editor.rpc"), + "host.events.subscribe" | "host.events.unsubscribe" => Some("events.subscribe"), + "host.registerPanel" | "host.unregisterPanel" => Some("ui.register"), + "host.registerCapability" | "host.unregisterCapability" => Some("capability.register"), + "host.registerCommand" | "host.unregisterCommand" => Some("ui.register"), + _ => None, + } +} + +impl PluginHost { + pub(crate) fn initialize(&self, config_dir: &Path) -> Result<(), String> { + let root = plugin_root(config_dir)?; + let mut state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + state.root = Some(root.clone()); + if state.workspace.is_none() { + if let Some(workspace) = std::env::var_os("AGC_PLUGIN_WORKSPACE") { + let workspace = PathBuf::from(workspace); + if workspace.is_dir() { + state.workspace = Some(workspace); + } + } + } + self.scan_locked(&mut state, &root) + } + + /// 注册 `plugins/` 工作区目录，让随包插件无需 AppData 导入即可被发现。 + pub(crate) fn set_plugin_workspace(&self, workspace: PathBuf) -> Result<(), String> { + if !workspace.is_dir() { + return Err("插件工作区必须是目录".to_string()); + } + let mut state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + state.workspace = Some(workspace); + let root = state + .root + .clone() + .ok_or_else(|| "插件宿主尚未初始化".to_string())?; + self.scan_locked(&mut state, &root) + } + + fn scan_locked(&self, state: &mut PluginHostState, root: &Path) -> Result<(), String> { + let workspace_sources = match state.workspace.clone() { + Some(workspace) => workspace_plugin_sources(&workspace)?, + None => Vec::new(), + }; + // 内置插件优先：随包插件不能被 AppData 同名导入覆盖，也不能被卸载。 + let mut sources = workspace_sources + .iter() + .filter(|source| crate::builtin_plugins::is_builtin(&source.id)) + .cloned() + .collect::>(); + for source in crate::client_extensions::client_plugin_sources_at(root)? + .into_iter() + .map(ScannedPluginSource::from_imported) + { + if !sources.iter().any(|existing| existing.id == source.id) { + sources.push(source); + } + } + for source in workspace_sources { + if !sources.iter().any(|existing| existing.id == source.id) { + sources.push(source); + } + } + let mut discovered = BTreeMap::new(); + for source in sources { + let id = source.id.clone(); + match read_plugin_manifest(&source.root) { + Ok(mut manifest) => { + if let Some(enabled) = source.enabled { + manifest.enabled = enabled; + } + if source.name != source.original_name { + manifest.name = source.name.clone(); + } + let existing = state + .plugins + .remove(&id) + .filter(|existing| existing.manifest == manifest && manifest.enabled); + let previous_error = existing + .as_ref() + .and_then(|existing| existing.last_error.clone()); + let previously_failed = existing + .as_ref() + .is_some_and(|existing| existing.status == "failed"); + let mut running = existing.and_then(|existing| existing.running); + let exited = running + .as_mut() + .and_then(|running| running.child.try_wait().ok().flatten()) + .is_some(); + if exited { + running = None; + } + let status = if !manifest.enabled { + "disabled" + } else if exited || previously_failed { + "failed" + } else if running.is_some() { + "running" + } else if manifest.entry.is_none() { + "package" + } else { + "stopped" + } + .to_string(); + discovered.insert( + id.clone(), + PluginRecord { + id, + manifest, + root: source.root, + status, + last_error: if exited { + Some("插件进程已退出".to_string()) + } else { + previous_error + }, + running, + }, + ); + } + Err(error) => { + discovered.insert( + id.clone(), + PluginRecord { + id: id.clone(), + manifest: PluginManifest { + id, + name: source.name, + version: "0".to_string(), + api_version: PLUGIN_API_VERSION.to_string(), + entry: None, + permissions: BTreeSet::new(), + enabled: false, + adapter: None, + panels: Vec::new(), + }, + root: source.root, + status: "invalid".to_string(), + last_error: Some(error), + running: None, + }, + ); + } + } + } + state.plugins = discovered; + Ok(()) + } + + fn registrations(record: &PluginRecord) -> PluginRegistrationsSnapshot { + let Some(running) = record.running.as_ref() else { + return PluginRegistrationsSnapshot::default(); + }; + let Ok(registrations) = running.registrations.lock() else { + return PluginRegistrationsSnapshot::default(); + }; + PluginRegistrationsSnapshot { + commands: registrations.commands.values().cloned().collect(), + panels: registrations.panels.values().cloned().collect(), + capabilities: registrations.capabilities.values().cloned().collect(), + } + } + + pub(crate) fn list(&self) -> Result, String> { + let mut state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + let root = state + .root + .clone() + .ok_or_else(|| "插件宿主尚未初始化".to_string())?; + self.scan_locked(&mut state, &root)?; + state + .plugins + .values() + .map(|record| self.summary_locked(record)) + .collect() + } + + pub(crate) fn refresh(&self) -> Result, String> { + self.list() + } + + pub(crate) fn list_extensions(&self) -> Result, String> { + let plugins = self.list()?; + let mut entries = plugins + .into_iter() + .map(|plugin| AgcExtensionSummary { + kind: "plugin".to_string(), + id: plugin.id.clone(), + name: plugin.name.clone(), + enabled: plugin.enabled, + builtin: plugin.builtin, + status: plugin.status.clone(), + plugin: Some(plugin), + client_extension: None, + }) + .collect::>(); + let root = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())? + .root + .clone() + .ok_or_else(|| "插件宿主尚未初始化".to_string())?; + for extension in crate::client_extensions::list_client_extensions_at(&root)? { + if extension.extension_type == "plugin" { + if let Some(entry) = entries.iter_mut().find(|entry| entry.id == extension.id) { + entry.client_extension = Some(extension); + } + continue; + } + entries.push(AgcExtensionSummary { + kind: extension.extension_type.clone(), + id: extension.id.clone(), + name: extension.name.clone(), + enabled: extension.enabled, + builtin: false, + status: extension.status.clone(), + plugin: None, + client_extension: Some(extension), + }); + } + entries.sort_by(|left, right| left.name.cmp(&right.name)); + Ok(entries) + } + + pub(crate) fn start(&self, id: &str) -> Result { + self.refresh()?; + let mut state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + let root = state + .root + .clone() + .ok_or_else(|| "插件宿主尚未初始化".to_string())?; + let active_project = state.active_project.clone(); + let editors = state.editors.clone(); + let record = state + .plugins + .get_mut(id) + .ok_or_else(|| "插件不存在".to_string())?; + if !record.manifest.enabled { + return Err("插件已禁用".to_string()); + } + if record.manifest.entry.is_none() { + return Err("该 Plugin 的 Skill/MCP 使用各自的运行适配器".to_string()); + } + if record.running.is_some() { + return self.summary_locked(record); + } + match spawn_plugin(&record.manifest, &record.root) { + Ok(running) => { + record.running = Some(running); + record.status = "running".to_string(); + record.last_error = None; + Self::start_plugin_pump(&root, active_project, editors, record); + audit(&root, id, "start", true, None); + } + Err(error) => { + record.status = "failed".to_string(); + record.last_error = Some(error.clone()); + audit(&root, id, "start", false, Some("spawn-failed")); + return Err(error); + } + } + self.summary_locked(record) + } + + pub(crate) fn stop(&self, id: &str) -> Result { + let mut state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + let root = state + .root + .clone() + .ok_or_else(|| "插件宿主尚未初始化".to_string())?; + let record = state + .plugins + .get_mut(id) + .ok_or_else(|| "插件不存在".to_string())?; + if let Some(mut running) = record.running.take() { + let _ = running.child.kill(); + let _ = running.child.wait(); + } + record.status = if record.manifest.enabled { + "stopped".to_string() + } else { + "disabled".to_string() + }; + record.last_error = None; + audit(&root, id, "stop", true, None); + self.summary_locked(record) + } + + pub(crate) fn reload(&self, id: &str) -> Result { + let _ = self.stop(id)?; + self.refresh()?; + self.start(id) + } + + /// 内置插件的可用开关：禁用时先停进程，再持久化状态并重新扫描。 + /// + /// 该状态同时被 Agent 工具目录消费，禁用后插件不能启动，对应 Runtime 工具 + /// 也不再出现在工具列表与 Agent 上下文里。 + pub(crate) fn set_enabled( + &self, + id: &str, + enabled: bool, + ) -> Result, String> { + if !crate::builtin_plugins::is_builtin(id) { + return Err("只有内置插件可以使用可用开关；导入扩展请使用扩展启用状态".to_string()); + } + if !enabled { + let _ = self.stop(id); + } + crate::builtin_plugins::set_enabled(id, enabled)?; + self.refresh() + } + + pub(crate) fn read_panel( + &self, + id: &str, + panel_id: &str, + ) -> Result { + let state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + let record = state + .plugins + .get(id) + .ok_or_else(|| "插件不存在".to_string())?; + if record.running.is_none() || !record.manifest.permissions.contains("ui.register") { + return Err("插件面板未激活".to_string()); + } + let panel = Self::registrations(record) + .panels + .into_iter() + .find(|panel| panel.id == panel_id) + .or_else(|| { + record + .manifest + .panels + .iter() + .find(|panel| panel.id == panel_id) + .map(|panel| PluginPanelDescriptor { + id: panel.id.clone(), + title: panel.title.clone(), + entry: panel.entry.clone(), + placement: panel.placement.clone(), + }) + }) + .ok_or_else(|| "插件面板未注册".to_string())?; + let path = project_read_path( + &record.root, + panel.entry.strip_prefix("./").unwrap_or(&panel.entry), + )?; + let bytes = fs::metadata(&path) + .map_err(|_| "插件面板不可读".to_string())? + .len(); + if bytes > MAX_RPC_BYTES as u64 { + return Err("插件面板过大".to_string()); + } + let html = fs::read_to_string(path).map_err(|_| "插件面板不是有效文本".to_string())?; + Ok(PluginPanelContent { panel, html }) + } + + pub(crate) fn call(&self, id: &str, method: String, params: Value) -> Result { + let (root, request_id, response_receiver, pending, writer, response_timeout) = { + let mut state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + let root = state + .root + .clone() + .ok_or_else(|| "插件宿主尚未初始化".to_string())?; + let record = state + .plugins + .get_mut(id) + .ok_or_else(|| "插件不存在".to_string())?; + let response_timeout = if record.manifest.adapter.is_some() { + EDITOR_RPC_TIMEOUT + } else { + RPC_TIMEOUT + }; + let running = record + .running + .as_mut() + .ok_or_else(|| "插件尚未启动".to_string())?; + let request_id = running.next_request_id; + running.next_request_id = request_id + .checked_add(1) + .ok_or_else(|| "插件 RPC id 已耗尽".to_string())?; + let (sender, receiver) = mpsc::channel(); + { + let mut pending = running + .pending + .lock() + .map_err(|_| "插件 RPC 等待队列锁已损坏".to_string())?; + if pending.len() >= 32 { + return Err("插件 RPC 并发请求过多".to_string()); + } + pending.insert(request_id, sender); + } + ( + root, + request_id, + receiver, + Arc::clone(&running.pending), + Arc::clone(&running.stdin), + response_timeout, + ) + }; + let deadline = Instant::now() + response_timeout; + let (write_sender, write_receiver) = mpsc::channel(); + thread::spawn(move || { + let _ = write_sender.send(write_rpc_shared( + &writer, + &json!({"jsonrpc":"2.0", "id":request_id, "method":method, "params":params}), + )); + }); + let result = match write_receiver.recv_timeout(RPC_TIMEOUT) { + Ok(Ok(())) => match response_receiver + .recv_timeout(deadline.saturating_duration_since(Instant::now())) + { + Ok(result) => result, + Err(RecvTimeoutError::Timeout) => Err("插件 RPC 响应超时".to_string()), + Err(RecvTimeoutError::Disconnected) => Err("插件进程已退出".to_string()), + }, + Ok(Err(error)) => Err(error), + Err(_) => { + self.terminate_rpc_instance(id, &pending); + Err("插件 RPC 写入超时".to_string()) + } + }; + if let Ok(mut pending) = pending.lock() { + pending.remove(&request_id); + } + audit( + &root, + id, + "rpc", + result.is_ok(), + result.as_ref().err().map(|_| "rpc-failed"), + ); + result + } + + fn terminate_rpc_instance(&self, id: &str, pending: &PendingRpc) { + if let Ok(mut state) = self.state.lock() { + if let Some(record) = state.plugins.get_mut(id) { + if record + .running + .as_ref() + .is_some_and(|running| Arc::ptr_eq(&running.pending, pending)) + { + record.running = None; + record.status = "failed".to_string(); + record.last_error = Some("插件 RPC 写入超时".to_string()); + } + } + } + } + + fn start_plugin_pump( + root: &Path, + active_project: ProjectContext, + editors: EditorRegistry, + record: &mut PluginRecord, + ) { + let Some(running) = record.running.as_mut() else { + return; + }; + let Some(lines) = running.lines.take() else { + return; + }; + let writer = Arc::clone(&running.stdin); + let pending = Arc::clone(&running.pending); + let registrations = Arc::clone(&running.registrations); + let manifest = record.manifest.clone(); + let root = root.to_path_buf(); + thread::spawn(move || { + while let Ok(line) = lines.recv() { + let Ok(envelope) = serde_json::from_str::(&line) else { + continue; + }; + if envelope.jsonrpc.as_deref() != Some("2.0") { + continue; + } + if envelope.method.is_none() { + if let Some(id) = envelope.id.as_ref().and_then(Value::as_u64) { + if let Ok(mut waiting) = pending.lock() { + if let Some(sender) = waiting.remove(&id) { + let result = envelope.error.map_or_else( + || { + envelope + .result + .ok_or_else(|| "插件 RPC 缺少 result".to_string()) + }, + |error| Err(format!("插件 RPC 错误：{error}")), + ); + let _ = sender.send(result); + continue; + } + } + } + } + if let Some(method) = envelope.method { + let response = Self::handle_host_request( + &root, + &active_project, + &editors, + &manifest, + ®istrations, + &method, + envelope.params, + ); + audit( + &root, + &manifest.id, + &method, + response.is_ok(), + response.as_ref().err().map(|_| "host-request-failed"), + ); + if let Some(id) = envelope.id { + let payload = match response { + Ok(result) => json!({"jsonrpc":"2.0","id":id,"result":result}), + Err(error) => { + json!({"jsonrpc":"2.0","id":id,"error":{"code":-32001,"message":error}}) + } + }; + let _ = write_rpc_shared(&writer, &payload); + } + } + } + if let Ok(mut waiting) = pending.lock() { + let remaining = std::mem::take(&mut *waiting); + for (_, sender) in remaining { + let _ = sender.send(Err("插件进程已退出".to_string())); + } + } + }); + } + + fn handle_host_request( + root: &Path, + active_project: &ProjectContext, + editors: &EditorRegistry, + manifest: &PluginManifest, + registrations: &Arc>, + method: &str, + params: Option, + ) -> Result { + if let Some(permission) = permission_for_method(method) { + if !manifest.permissions.contains(permission) { + audit(root, &manifest.id, method, false, Some("permission-denied")); + return Err(format!("插件缺少权限：{permission}")); + } + } + match method { + "host.registerCommand" => { + let input: RegisterCommandInput = descriptor_from_params(params)?; + if !valid_identifier(&input.id) || !valid_text(&input.title, 80) { + return Err("命令声明无效".to_string()); + } + register_entry( + &mut registrations + .lock() + .map_err(|_| "插件注册表锁已损坏".to_string())? + .commands, + input.id.clone(), + PluginCommandDescriptor { + id: input.id, + title: input.title, + description: input.description, + }, + )?; + Ok(json!({"registered": true})) + } + "host.unregisterCommand" => { + let id = params + .and_then(|value| value.get("id").and_then(Value::as_str).map(str::to_string)) + .ok_or_else(|| "缺少命令 id".to_string())?; + registrations + .lock() + .map_err(|_| "插件注册表锁已损坏".to_string())? + .commands + .remove(&id); + Ok(json!({"unregistered": true})) + } + "host.registerPanel" => { + let input: RegisterPanelInput = descriptor_from_params(params)?; + if !valid_identifier(&input.id) || !valid_text(&input.title, 80) { + return Err("面板声明无效".to_string()); + } + validate_relative_path(&input.entry)?; + register_entry( + &mut registrations + .lock() + .map_err(|_| "插件注册表锁已损坏".to_string())? + .panels, + input.id.clone(), + PluginPanelDescriptor { + id: input.id, + title: input.title, + entry: input.entry, + placement: input.placement, + }, + )?; + Ok(json!({"registered": true})) + } + "host.unregisterPanel" => { + let id = params + .and_then(|value| value.get("id").and_then(Value::as_str).map(str::to_string)) + .ok_or_else(|| "缺少面板 id".to_string())?; + registrations + .lock() + .map_err(|_| "插件注册表锁已损坏".to_string())? + .panels + .remove(&id); + Ok(json!({"unregistered": true})) + } + "host.registerCapability" => { + let input: RegisterCapabilityInput = descriptor_from_params(params)?; + if !valid_identifier(&input.id) { + return Err("能力声明无效".to_string()); + } + register_entry( + &mut registrations + .lock() + .map_err(|_| "插件注册表锁已损坏".to_string())? + .capabilities, + input.id.clone(), + PluginCapabilityDescriptor { + id: input.id, + description: input.description, + }, + )?; + Ok(json!({"registered": true})) + } + "host.unregisterCapability" => { + let id = params + .and_then(|value| value.get("id").and_then(Value::as_str).map(str::to_string)) + .ok_or_else(|| "缺少能力 id".to_string())?; + registrations + .lock() + .map_err(|_| "插件注册表锁已损坏".to_string())? + .capabilities + .remove(&id); + Ok(json!({"unregistered": true})) + } + "host.events.subscribe" => { + let event_type = params + .as_ref() + .and_then(|params| params.get("type")) + .and_then(Value::as_str) + .filter(|name| valid_text(name, 120)) + .ok_or_else(|| "事件名称无效".to_string())?; + let id = format!("sub-{}", uuid::Uuid::new_v4().simple()); + register_entry( + &mut registrations + .lock() + .map_err(|_| "插件注册表锁已损坏".to_string())? + .subscriptions, + id.clone(), + event_type.to_string(), + )?; + let project_path = active_project + .lock() + .map_err(|_| "项目上下文锁已损坏".to_string())? + .clone() + .map(|path| path.to_string_lossy().into_owned()); + Ok(json!({"subscriptionId": id, "projectPath": project_path})) + } + "host.events.unsubscribe" => { + let id = params + .as_ref() + .and_then(|params| params.get("subscriptionId")) + .and_then(Value::as_str) + .ok_or_else(|| "缺少订阅 id".to_string())?; + registrations + .lock() + .map_err(|_| "插件注册表锁已损坏".to_string())? + .subscriptions + .remove(id); + Ok(json!({"unsubscribed": true})) + } + "host.project.read" => { + let input: ProjectReadInput = descriptor_from_params(params)?; + let project = active_project + .lock() + .map_err(|_| "项目上下文锁已损坏".to_string())? + .clone() + .ok_or_else(|| "尚未设置当前项目".to_string())?; + let path = project_read_path(&project, &input.path)?; + let metadata = fs::symlink_metadata(&path) + .map_err(|error| format!("读取项目文件失败：{error}"))?; + if metadata.file_type().is_symlink() + || !metadata.is_file() + || metadata.len() > MAX_RPC_BYTES as u64 + { + return Err("项目文件不可读或超过大小限制".to_string()); + } + let content = fs::read_to_string(&path) + .map_err(|error| format!("读取项目文件失败：{error}"))?; + Ok(json!({"path": input.path, "content": content})) + } + "host.rpc" => { + let input: EditorRpcInput = descriptor_from_params(params)?; + let adapter = input + .adapter + .or_else(|| manifest.adapter.clone()) + .ok_or_else(|| "插件未指定编辑器适配器".to_string())?; + let editors = editors + .lock() + .map_err(|_| "编辑器注册表锁已损坏".to_string())?; + let editor = editors + .get(&adapter) + .ok_or_else(|| format!("未知编辑器适配器：{adapter}"))?; + editor.rpc(&input.method, input.params) + } + _ => Err(format!("宿主不支持 RPC 方法：{method}")), + } + } + + fn summary_locked(&self, record: &PluginRecord) -> Result { + let registrations = Self::registrations(record); + let mut panels = record + .manifest + .panels + .iter() + .map(|panel| { + ( + panel.id.clone(), + PluginPanelDescriptor { + id: panel.id.clone(), + title: panel.title.clone(), + entry: panel.entry.clone(), + placement: panel.placement.clone(), + }, + ) + }) + .collect::>(); + for panel in registrations.panels { + panels.insert(panel.id.clone(), panel); + } + Ok(PluginSummary { + id: record.id.clone(), + name: record.manifest.name.clone(), + version: record.manifest.version.clone(), + api_version: record.manifest.api_version.clone(), + enabled: record.manifest.enabled, + builtin: crate::builtin_plugins::is_builtin(&record.id), + has_runtime: record.manifest.entry.is_some(), + status: record.status.clone(), + adapter: record.manifest.adapter.clone(), + permissions: record.manifest.permissions.iter().cloned().collect(), + commands: registrations.commands, + panels: panels.into_values().collect(), + capabilities: registrations.capabilities, + last_error: record.last_error.clone(), + }) + } + + pub(crate) fn set_active_project(&self, project_path: Option) -> Result<(), String> { + let state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + let project = project_path + .map(|path| { + let path = PathBuf::from(path); + if !path.is_dir() { + return Err("项目路径必须是目录".to_string()); + } + path.canonicalize() + .map_err(|_| "项目目录不可读".to_string()) + }) + .transpose()?; + *state + .active_project + .lock() + .map_err(|_| "项目上下文锁已损坏".to_string())? = project; + for record in state.plugins.values() { + if let Some(running) = record.running.as_ref() { + let subscribed = running + .registrations + .lock() + .map_err(|_| "插件注册表锁已损坏".to_string())? + .subscriptions + .values() + .any(|name| name == "project.changed"); + if subscribed { + let _ = write_rpc_shared( + &running.stdin, + &json!({ + "jsonrpc":"2.0", + "method":"host.event", + "params":{ + "type":"project.changed", + "payload":{"projectPath": state + .active_project + .lock() + .map_err(|_| "项目上下文锁已损坏".to_string())? + .as_ref() + .map(|path| path.to_string_lossy().into_owned())}, + }, + }), + ); + } + } + } + Ok(()) + } + + pub(crate) fn register_editor_adapter( + &self, + adapter: Box, + ) -> Result<(), String> { + let state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + let mut editors = state + .editors + .lock() + .map_err(|_| "编辑器注册表锁已损坏".to_string())?; + if editors.contains_key(adapter.id()) { + return Err("编辑器适配器已注册".to_string()); + } + editors.insert(adapter.id().to_string(), adapter); + Ok(()) + } + + pub(crate) fn detect_editor( + &self, + adapter: String, + project_path: String, + ) -> Result { + let state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + let editors = state + .editors + .lock() + .map_err(|_| "编辑器注册表锁已损坏".to_string())?; + editors + .get(&adapter) + .ok_or_else(|| format!("未知编辑器适配器：{adapter}"))? + .detect(Path::new(project_path.trim())) + } + + pub(crate) fn connect_editor( + &self, + adapter: String, + pid: u32, + project_path: String, + version: String, + ) -> Result { + let state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + let mut editors = state + .editors + .lock() + .map_err(|_| "编辑器注册表锁已损坏".to_string())?; + editors + .get_mut(&adapter) + .ok_or_else(|| format!("未知编辑器适配器：{adapter}"))? + .connect(pid, Path::new(project_path.trim()), version.trim()) + } + + pub(crate) fn disconnect_editor(&self, adapter: String) -> Result<(), String> { + let state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + let mut editors = state + .editors + .lock() + .map_err(|_| "编辑器注册表锁已损坏".to_string())?; + editors + .get_mut(&adapter) + .ok_or_else(|| format!("未知编辑器适配器：{adapter}"))? + .disconnect(); + Ok(()) + } + + pub(crate) fn translate_editor_rpc( + &self, + adapter: String, + method: String, + params: Value, + ) -> Result { + let state = self + .state + .lock() + .map_err(|_| "插件宿主锁已损坏".to_string())?; + let editors = state + .editors + .lock() + .map_err(|_| "编辑器注册表锁已损坏".to_string())?; + editors + .get(&adapter) + .ok_or_else(|| format!("未知编辑器适配器：{adapter}"))? + .translate_rpc(&method, params) + } +} + +#[tauri::command] +pub(crate) fn list_agc_plugins(host: State<'_, PluginHost>) -> Result, String> { + host.list() +} + +#[tauri::command] +pub(crate) fn list_agc_extensions( + host: State<'_, PluginHost>, +) -> Result, String> { + host.list_extensions() +} + +#[tauri::command] +pub(crate) fn refresh_agc_plugins( + host: State<'_, PluginHost>, +) -> Result, String> { + host.refresh() +} + +#[tauri::command] +pub(crate) fn start_agc_plugin( + id: String, + host: State<'_, PluginHost>, +) -> Result { + host.start(id.trim()) +} + +#[tauri::command] +pub(crate) fn stop_agc_plugin( + id: String, + host: State<'_, PluginHost>, +) -> Result { + host.stop(id.trim()) +} + +#[tauri::command] +pub(crate) fn reload_agc_plugin( + id: String, + host: State<'_, PluginHost>, +) -> Result { + host.reload(id.trim()) +} + +#[tauri::command] +pub(crate) fn set_agc_plugin_enabled( + id: String, + enabled: bool, + host: State<'_, PluginHost>, +) -> Result, String> { + host.set_enabled(id.trim(), enabled) +} + +#[tauri::command] +pub(crate) async fn call_agc_plugin( + id: String, + method: String, + params: Value, + app: tauri::AppHandle, +) -> Result { + if !valid_text(&method, 120) || method.chars().any(char::is_control) { + return Err("插件 RPC 方法无效".to_string()); + } + tauri::async_runtime::spawn_blocking(move || { + app.state::().call(id.trim(), method, params) + }) + .await + .map_err(|_| "插件 RPC 任务失败".to_string())? +} + +#[tauri::command] +pub(crate) fn read_agc_plugin_panel( + id: String, + panel_id: String, + host: State<'_, PluginHost>, +) -> Result { + host.read_panel(&id, &panel_id) +} + +#[tauri::command] +pub(crate) fn set_agc_plugin_project_path( + project_path: Option, + host: State<'_, PluginHost>, +) -> Result<(), String> { + host.set_active_project(project_path) +} + +#[cfg(test)] +mod tests { + use super::*; + use tempfile::tempdir; + + fn manifest() -> PluginManifest { + PluginManifest { + id: "sample-plugin".to_string(), + name: "Sample".to_string(), + version: "1.0.0".to_string(), + api_version: PLUGIN_API_VERSION.to_string(), + entry: Some("index.js".to_string()), + permissions: ["ui.register".to_string()].into_iter().collect(), + enabled: true, + adapter: None, + panels: Vec::new(), + } + } + + fn write_fixture(plugin: &Path, script: &str) { + fs::create_dir_all(plugin).expect("plugin directory"); + fs::write( + plugin.join("plugin.json"), + json!({ + "$schema": AGENT_PLUGINS_SCHEMA, + "name": "sample-plugin", + "version": "1.0.0", + "extensions": { + "world.genarrative.agc": { + "entry": "index.js", + "permissions": ["ui.register"] + } + } + }) + .to_string(), + ) + .expect("manifest"); + fs::write(plugin.join("index.js"), script).expect("entry"); + } + + fn import_fixture(config: &Path, plugin: &Path) -> String { + crate::client_extensions::import_client_extension_at( + &config.join("extensions"), + plugin, + &fs::metadata(plugin).expect("metadata"), + ) + .expect("import plugin") + .imported + .into_iter() + .find(|item| item.extension_type == "plugin") + .expect("plugin item") + .id + } + + #[test] + fn validates_manifest_and_rejects_traversal() { + let mut value = manifest(); + assert!(validate_manifest(&value).is_ok()); + value.entry = Some("../escape.js".to_string()); + assert!(validate_manifest(&value).is_err()); + } + + #[test] + fn scans_and_lists_plugin_manifest() { + let directory = tempdir().expect("temp config"); + let plugin = directory.path().join("plugins/sample"); + write_fixture(&plugin, "process.stdin.resume();"); + let id = import_fixture(directory.path(), &plugin); + let host = PluginHost::default(); + host.initialize(directory.path()).expect("initialize"); + let list = host.list().expect("list"); + assert_eq!(list.len(), 1); + assert_eq!(list[0].id, id); + } + + fn write_workspace_plugin(workspace: &Path, name: &str, enabled: bool) { + let plugin = workspace.join(name); + fs::create_dir_all(&plugin).expect("plugin directory"); + fs::write( + plugin.join("plugin.json"), + json!({ + "$schema": AGENT_PLUGINS_SCHEMA, + "name": name, + "version": "1.0.0", + "extensions": { + "world.genarrative.agc": { + "entry": "index.js", + "permissions": ["ui.register"], + "enabled": enabled + } + } + }) + .to_string(), + ) + .expect("manifest"); + fs::write(plugin.join("index.js"), "process.stdin.resume();").expect("entry"); + } + + #[test] + fn scans_plugins_workspace_and_honors_manifest_enabled_flag() { + let directory = tempdir().expect("temp config"); + let workspace = directory.path().join("workspace"); + write_workspace_plugin(&workspace, "sample-plugin", true); + write_workspace_plugin(&workspace, "disabled-plugin", false); + let host = PluginHost::default(); + host.initialize(directory.path()).expect("initialize"); + assert!(host.list().expect("list before workspace").is_empty()); + host.set_plugin_workspace(workspace.clone()) + .expect("set workspace"); + let list = host.list().expect("list after workspace"); + assert_eq!(list.len(), 2); + let enabled = list + .iter() + .find(|plugin| plugin.id == "sample-plugin") + .expect("enabled plugin"); + assert!(enabled.enabled); + assert_eq!(enabled.status, "stopped"); + assert_eq!(enabled.adapter, None); + let disabled = list + .iter() + .find(|plugin| plugin.id == "disabled-plugin") + .expect("disabled plugin"); + assert!(!disabled.enabled); + assert_eq!(disabled.status, "disabled"); + } + + #[test] + fn denies_ungranted_host_registration() { + let directory = tempdir().expect("temp config"); + let plugin = directory.path().join("plugins/sample"); + write_fixture(&plugin, "process.stdin.resume();"); + let id = import_fixture(directory.path(), &plugin); + let host = PluginHost::default(); + host.initialize(directory.path()).expect("initialize"); + let mut state = host.state.lock().expect("host lock"); + let record = state.plugins.get_mut(&id).expect("record"); + let context = ProjectContext::default(); + let editors = EditorRegistry::default(); + let registrations = Arc::new(Mutex::new(PluginRegistrations::default())); + assert!(PluginHost::handle_host_request( + directory.path().join("extensions").as_path(), + &context, + &editors, + &record.manifest, + ®istrations, + "host.project.read", + None + ) + .is_err()); + } + + #[test] + fn portable_skill_only_package_does_not_require_a_process_entry() { + let directory = tempdir().expect("temp plugin"); + fs::write( + directory.path().join("plugin.json"), + json!({ + "$schema": AGENT_PLUGINS_SCHEMA, + "name": "skills-only" + }) + .to_string(), + ) + .expect("manifest"); + let parsed = read_plugin_manifest(directory.path()).expect("portable manifest"); + assert!(parsed.entry.is_none()); + assert_eq!(parsed.id, "skills-only"); + } + + #[test] + fn process_handles_idle_registration_rpc_and_stop() { + let directory = tempdir().expect("temp config"); + let plugin = directory.path().join("plugins/sample"); + write_fixture( + &plugin, + r#" +const readline = require('node:readline'); +const send = value => process.stdout.write(JSON.stringify(value) + '\n'); +readline.createInterface({ input: process.stdin }).on('line', line => { + const message = JSON.parse(line); + if (message.method === 'echo') send({ jsonrpc: '2.0', id: message.id, result: message.params }); +}); +setTimeout(() => send({ jsonrpc: '2.0', id: 1, method: 'host.registerCommand', params: { id: 'hello', title: 'Hello' } }), 100); +"#, + ); + let id = import_fixture(directory.path(), &plugin); + let host = PluginHost::default(); + host.initialize(directory.path()).expect("initialize"); + host.start(&id).expect("start"); + let deadline = std::time::Instant::now() + Duration::from_secs(3); + loop { + if host.list().expect("list")[0].commands.len() == 1 { + break; + } + assert!( + std::time::Instant::now() < deadline, + "idle registration was not dispatched" + ); + thread::sleep(Duration::from_millis(25)); + } + assert_eq!( + host.call(&id, "echo".to_string(), json!({"ok": true})) + .expect("RPC"), + json!({"ok": true}) + ); + assert_eq!( + host.call(&id, "echo".to_string(), Value::Null) + .expect("null RPC result"), + Value::Null + ); + assert_eq!(host.stop(&id).expect("stop").status, "stopped"); + } + + #[test] + fn output_without_a_bounded_newline_is_rejected() { + let mut reader = std::io::Cursor::new(vec![b'a'; MAX_RPC_BYTES + 1]); + assert!(read_bounded_rpc_line(&mut reader).is_err()); + } + + struct StubCocosAdapter; + + impl EditorAdapter for StubCocosAdapter { + fn id(&self) -> &'static str { + "cocos-editor" + } + + fn detect(&self, _project_path: &Path) -> Result { + Err("stub adapter 不探测进程".to_string()) + } + + fn connect( + &mut self, + _pid: u32, + _project_path: &Path, + _version: &str, + ) -> Result { + Err("stub adapter 不建立连接".to_string()) + } + + fn disconnect(&mut self) {} + + fn translate_rpc(&self, _method: &str, params: Value) -> Result { + Ok(params) + } + + fn rpc(&self, method: &str, params: Value) -> Result { + // 与 native 适配器的 CocosEditorCommandResponse 同形，供插件入口判断 status。 + Ok(json!({"ok": true, "method": method, "params": params})) + } + } + + #[test] + fn builtin_plugin_toggle_controls_availability() { + let _guard = crate::builtin_plugins::test_lock(); + let directory = tempdir().expect("temp config"); + let workspace = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../plugins"); + let host = PluginHost::default(); + crate::builtin_plugins::initialize(directory.path()).expect("builtin plugin state"); + host.initialize(directory.path()).expect("initialize"); + host.set_plugin_workspace(workspace) + .expect("set plugins workspace"); + + let summary = |list: Vec| { + list.into_iter() + .find(|plugin| plugin.id == "agc-cocos-editor") + .expect("built-in plugin") + }; + let enabled = summary(host.list().expect("list")); + assert!(enabled.builtin); + assert!(enabled.enabled); + + let disabled = summary( + host.set_enabled("agc-cocos-editor", false) + .expect("disable built-in plugin"), + ); + assert!(!disabled.enabled); + assert_eq!(disabled.status, "disabled"); + assert!(host.start("agc-cocos-editor").is_err()); + assert!(host + .set_enabled("imported-extension", false) + .expect_err("imported extensions use the extension index") + .contains("只有内置插件")); + + let re_enabled = summary( + host.set_enabled("agc-cocos-editor", true) + .expect("enable built-in plugin"), + ); + assert!(re_enabled.enabled); + assert_eq!(re_enabled.status, "stopped"); + } + + #[test] + fn workspace_cocos_plugin_round_trips_editor_rpc() { + let _guard = crate::builtin_plugins::test_lock(); + let directory = tempdir().expect("temp config"); + crate::builtin_plugins::initialize(directory.path()).expect("builtin state"); + let workspace = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../../plugins"); + let host = PluginHost::default(); + host.initialize(directory.path()).expect("initialize"); + host.set_plugin_workspace(workspace) + .expect("set plugins workspace"); + host.register_editor_adapter(Box::new(StubCocosAdapter)) + .expect("register adapter"); + let project = fs::canonicalize(directory.path()) + .expect("canonical project") + .to_string_lossy() + .into_owned(); + host.set_active_project(Some(project.clone())) + .expect("set active project"); + host.start("agc-cocos-editor").expect("start plugin"); + let deadline = std::time::Instant::now() + Duration::from_secs(15); + loop { + let registered = host.list().expect("list").into_iter().any(|plugin| { + plugin.id == "agc-cocos-editor" + && plugin.commands.len() == 2 + && plugin.capabilities.len() == 1 + && plugin.panels.len() == 1 + }); + if registered { + break; + } + assert!( + std::time::Instant::now() < deadline, + "Cocos 插件未在期限内完成注册" + ); + thread::sleep(Duration::from_millis(25)); + } + let response = host + .call( + "agc-cocos-editor", + "cocos.editor.execute".to_string(), + json!({"code": "return 1 + 1;"}), + ) + .expect("cocos execute rpc"); + assert_eq!(response["status"], "completed"); + assert_eq!(response["response"]["method"], "editor.execute"); + assert_eq!(response["response"]["params"]["projectPath"], project); + assert_eq!(response["response"]["params"]["code"], "return 1 + 1;"); + assert_eq!( + host.stop("agc-cocos-editor").expect("stop plugin").status, + "stopped" + ); + } +} diff --git a/apps/ai-game-creator-shell/src-tauri/src/preview.rs b/apps/ai-game-creator-shell/src-tauri/src/preview.rs index f79c9bc39..a446ec666 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/preview.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/preview.rs @@ -756,7 +756,15 @@ pub(crate) fn get_local_game_preview_status_at( } #[tauri::command] -pub(crate) fn get_local_game_project_revision( +pub(crate) async fn get_local_game_project_revision( + project_path: String, +) -> Result { + tauri::async_runtime::spawn_blocking(move || get_local_game_project_revision_sync(project_path)) + .await + .map_err(|error| format!("读取项目版本后台任务失败：{error}"))? +} + +pub(crate) fn get_local_game_project_revision_sync( project_path: String, ) -> Result { get_local_game_project_revision_at(Path::new(project_path.trim())) diff --git a/apps/ai-game-creator-shell/src-tauri/src/process_session/model.rs b/apps/ai-game-creator-shell/src-tauri/src/process_session/model.rs index e01ac259d..7ce96436e 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/process_session/model.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/process_session/model.rs @@ -204,7 +204,7 @@ pub(super) struct LiveProcessSession { } #[cfg(windows)] -pub(super) struct WindowsProcessJob(windows_sys::Win32::Foundation::HANDLE); +pub(crate) struct WindowsProcessJob(windows_sys::Win32::Foundation::HANDLE); #[cfg(windows)] unsafe impl Send for WindowsProcessJob {} @@ -215,6 +215,21 @@ unsafe impl Sync for WindowsProcessJob {} #[cfg(windows)] impl WindowsProcessJob { pub(super) fn assign(child: &dyn Child) -> Result { + let process = child + .as_raw_handle() + .ok_or_else(|| "command.start Windows child 缺少 process handle".to_string())? + as windows_sys::Win32::Foundation::HANDLE; + Self::assign_handle(process) + } + + pub(crate) fn assign_std(child: &std::process::Child) -> Result { + use std::os::windows::io::AsRawHandle; + Self::assign_handle( + AsRawHandle::as_raw_handle(child) as windows_sys::Win32::Foundation::HANDLE + ) + } + + fn assign_handle(process: windows_sys::Win32::Foundation::HANDLE) -> Result { use std::mem::size_of; use windows_sys::Win32::Foundation::{CloseHandle, INVALID_HANDLE_VALUE}; use windows_sys::Win32::System::JobObjects::{ @@ -223,10 +238,6 @@ impl WindowsProcessJob { JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, }; - let process = child - .as_raw_handle() - .ok_or_else(|| "command.start Windows child 缺少 process handle".to_string())? - as windows_sys::Win32::Foundation::HANDLE; let handle = unsafe { CreateJobObjectW(std::ptr::null(), std::ptr::null()) }; if handle.is_null() || handle == INVALID_HANDLE_VALUE { return Err(format!( diff --git a/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs b/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs index c9e73140c..767e77292 100644 --- a/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs +++ b/apps/ai-game-creator-shell/src-tauri/src/project/manifest.rs @@ -169,6 +169,80 @@ fn validate_manifest_godot_project_root(value: Option<&str>) -> Result<(), Strin .map_err(|error| format!("manifest godotProjectRoot 无效：{error}")) } +fn validate_manifest_cocos_project_root(value: Option<&str>) -> Result<(), String> { + let Some(value) = value else { + return Ok(()); + }; + if value != "." { + return Err("manifest cocosProjectRoot 只能是 .".to_string()); + } + Ok(()) +} + +pub(crate) fn discover_local_cocos_project_root( + workspace_root: &Path, +) -> Result, String> { + if workspace_root.as_os_str().is_empty() || !workspace_root.is_absolute() { + return Err("Cocos 项目目录必须是绝对路径".to_string()); + } + if project_path_has_control_chars(workspace_root) { + return Err("Cocos 项目目录不能包含控制字符".to_string()); + } + let metadata = match fs::symlink_metadata(workspace_root) { + Ok(metadata) => metadata, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None), + Err(error) => { + return Err(format!( + "读取 Cocos 项目目录失败：{}: {error}", + workspace_root.display() + )); + } + }; + if godot_metadata_is_link(&metadata) || !metadata.is_dir() { + return Ok(None); + } + let package_path = workspace_root.join("package.json"); + let package_metadata = match fs::symlink_metadata(&package_path) { + Ok(metadata) => metadata, + Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(None), + Err(error) => { + return Err(format!( + "读取 Cocos package.json 失败：{}: {error}", + package_path.display() + )); + } + }; + if godot_metadata_is_link(&package_metadata) || !package_metadata.is_file() { + return Ok(None); + } + let package_text = fs::read_to_string(&package_path).map_err(|error| { + format!( + "读取 Cocos package.json 失败：{}: {error}", + package_path.display() + ) + })?; + let package: serde_json::Value = serde_json::from_str(&package_text).map_err(|error| { + format!( + "解析 Cocos package.json 失败：{}: {error}", + package_path.display() + ) + })?; + let creator_version = package + .get("creator") + .and_then(|creator| creator.get("version")) + .and_then(serde_json::Value::as_str) + .filter(|version| !version.trim().is_empty()); + let assets = workspace_root.join("assets"); + let assets_metadata = fs::symlink_metadata(&assets).ok(); + if creator_version.is_none() + || !assets_metadata + .is_some_and(|metadata| !godot_metadata_is_link(&metadata) && metadata.is_dir()) + { + return Ok(None); + } + Ok(Some(".".to_string())) +} + pub(crate) fn discover_local_godot_project_root( workspace_root: &Path, ) -> Result, String> { @@ -626,6 +700,67 @@ pub(crate) fn import_local_godot_project_at( }) } +pub(crate) fn import_local_cocos_project_at( + root: &Path, + project_id: &str, + name: &str, +) -> Result { + if root.as_os_str().is_empty() || !root.is_absolute() { + return Err("Cocos 项目目录必须是绝对路径".to_string()); + } + if project_path_has_control_chars(root) { + return Err("Cocos 项目目录不能包含控制字符".to_string()); + } + prepare_game_creator_project_root_for_read(root, true, "Cocos 工作区目录")?; + discover_local_cocos_project_root(root)?.ok_or_else(|| { + "所选目录不是有效的 Cocos Creator 项目（需要 package.json.creator.version 和 assets/）" + .to_string() + })?; + if project_id.is_empty() { + return Err("项目 ID 不能为空".to_string()); + } + let name = normalize_game_creation_project_name(name)?; + let manifest_path = root.join(".agent/manifest.json"); + if manifest_storage_exists(&manifest_path)? { + let mut manifest = read_manifest(&manifest_path)?; + if manifest.cocos_project_root.as_deref() != Some(".") { + manifest.cocos_project_root = Some(".".to_string()); + write_manifest(&manifest_path, &manifest)?; + } + return Ok(InitLocalProjectResult { + project_path: root.to_string_lossy().into_owned(), + manifest_path: manifest_path.to_string_lossy().into_owned(), + manifest, + }); + } + let agent_db_path = root.join(".agent/agent.db"); + if !agent_db_path.exists() { + append_agent_db_record( + root, + serde_json::json!({ + "recordType": "project.import", + "projectId": project_id, + "name": name, + "projectKind": "cocos", + "cocosProjectRoot": ".", + }), + )?; + } + for relative in [".agent/logs", ".agent/runtime"] { + let path = root.join(relative); + ensure_game_creator_private_directory_tree(&path, "Cocos 项目 Agent 目录")?; + prepare_game_creator_private_path_for_read(&path, true, "Cocos 项目 Agent 目录")?; + } + let mut manifest = new_game_creation_app_manifest(project_id, name); + manifest.cocos_project_root = Some(".".to_string()); + write_manifest(&manifest_path, &manifest)?; + Ok(InitLocalProjectResult { + project_path: root.to_string_lossy().into_owned(), + manifest_path: manifest_path.to_string_lossy().into_owned(), + manifest, + }) +} + pub(crate) fn record_preview_state( root: &Path, status: GameCreationAppPreviewStatus, @@ -1374,6 +1509,8 @@ pub(crate) fn read_manifest(path: &Path) -> Result(null); - localProjectPathRef.current = localProject?.projectPath ?? null; + + useEffect(() => { + if (supervisorChatOnly) return; + const nextProjectPath = localProject?.projectPath ?? null; + const previousProjectPath = localProjectPathRef.current; + localProjectPathRef.current = nextProjectPath; + // 未绑定项目时无需触发插件宿主；这也避免启动空首页时产生无意义的 Tauri 调用。 + if (!nextProjectPath && !previousProjectPath) return; + void setAgcPluginProjectPath(nextProjectPath) + .then(async () => { + if (workspaceProjectKind === 'cocos' && nextProjectPath) { + await startAgcPlugin('agc-cocos-editor'); + } + }) + .catch((error) => { + if (workspaceProjectKind !== 'cocos' || !nextProjectPath) { + return; + } + setWorkspaceStatus( + `Cocos Creator 插件未就绪：${ + error instanceof Error ? error.message : String(error) + }`, + ); + }); + return () => { + if (nextProjectPath || previousProjectPath) { + void setAgcPluginProjectPath(null).catch(() => undefined); + } + localProjectPathRef.current = null; + }; + }, [localProject?.projectPath, supervisorChatOnly, workspaceProjectKind]); const manifestRefreshMountedRef = useRef(true); const manifestRefreshStatesRef = useRef( @@ -1545,7 +1576,9 @@ export function App({ void openWorkspace( initialProjectPath, false, - initialProjectKind === 'godot' ? 'open' : 'create', + initialProjectKind === 'godot' || initialProjectKind === 'cocos' + ? 'open' + : 'create', initialProjectKind, ); // Initial project opening is guarded by initialProjectOpenedRef. @@ -11146,6 +11179,7 @@ export function App({ const nextProjectPath = localProject?.projectPath ?? null; if ( !projectSupervisorOnly || + directCodexProductRuntime || !invoke || !nextProjectPath || professionalResultCandidates.length === 0 @@ -11227,6 +11261,7 @@ export function App({ // The semantic candidate key replaces the freshly allocated candidates array. // eslint-disable-next-line react-hooks/exhaustive-deps }, [ + directCodexProductRuntime, localProject?.projectPath, professionalResultCandidateKey, projectSupervisorOnly, diff --git a/apps/ai-game-creator-shell/src/app/types.ts b/apps/ai-game-creator-shell/src/app/types.ts index cf57ba3a4..a89c1698a 100644 --- a/apps/ai-game-creator-shell/src/app/types.ts +++ b/apps/ai-game-creator-shell/src/app/types.ts @@ -51,7 +51,7 @@ export type LauncherImportedAttachment = { size?: number; }; -export type ClientExtensionType = 'skill' | 'mcp' | 'unknown'; +export type ClientExtensionType = 'plugin' | 'skill' | 'mcp' | 'unknown'; export type ClientExtensionItem = { id: string; @@ -72,7 +72,63 @@ export type ClientExtensionImportResult = { duplicate: boolean; }; -export type LocalProjectKind = 'web' | 'godot'; +export type AgcPluginStatus = + | 'package' + | 'discovered' + | 'stopped' + | 'running' + | 'failed' + | 'disabled' + | 'invalid'; + +export type AgcPluginCommand = { + id: string; + title: string; + description: string | null; +}; + +export type AgcPluginPanel = { + id: string; + title: string; + entry: string; + placement: string | null; +}; + +export type AgcPluginCapability = { + id: string; + description: string | null; +}; + +export type AgcPluginSummary = { + id: string; + name: string; + version: string; + apiVersion: string; + enabled: boolean; + /** 内置插件随包分发、不能卸载，只能通过可用开关控制。 */ + builtin: boolean; + hasRuntime: boolean; + status: AgcPluginStatus; + adapter: string | null; + permissions: string[]; + commands: AgcPluginCommand[]; + panels: AgcPluginPanel[]; + capabilities: AgcPluginCapability[]; + lastError: string | null; +}; + +export type AgcExtensionSummary = { + kind: 'plugin' | 'skill' | 'mcp' | 'unknown'; + id: string; + name: string; + enabled: boolean; + builtin: boolean; + status: string; + plugin: AgcPluginSummary | null; + clientExtension: ClientExtensionItem | null; +}; + +export type LocalProjectKind = 'web' | 'godot' | 'cocos'; export type ProjectStartMode = 'planning' | 'direct-build'; @@ -126,6 +182,8 @@ export interface LocalProjectDirectoryStatus { isGameCreatorProject: boolean; isGodotProject: boolean; godotProjectRoot: string | null; + isCocosProject?: boolean; + cocosProjectRoot?: string | null; projectName: string | null; modifiedAt?: number | null; manifestError?: string | null; diff --git a/apps/ai-game-creator-shell/src/features/agent-runtime/model.ts b/apps/ai-game-creator-shell/src/features/agent-runtime/model.ts index 5067cc052..4c331835c 100644 --- a/apps/ai-game-creator-shell/src/features/agent-runtime/model.ts +++ b/apps/ai-game-creator-shell/src/features/agent-runtime/model.ts @@ -40,7 +40,7 @@ export function resolveProjectSupervisorRuntimeSubmission({ supervisorChatOnly, planningEntry = false, }: { - workspaceProjectKind: 'web' | 'godot'; + workspaceProjectKind: 'web' | 'godot' | 'cocos'; orchestrationMode: 'single-supervisor' | 'professional-dag'; supervisorChatOnly: boolean; planningEntry?: boolean; diff --git a/apps/ai-game-creator-shell/src/features/app-shell/ProjectCreation.tsx b/apps/ai-game-creator-shell/src/features/app-shell/ProjectCreation.tsx index 2aad6e5c3..69ae5d245 100644 --- a/apps/ai-game-creator-shell/src/features/app-shell/ProjectCreation.tsx +++ b/apps/ai-game-creator-shell/src/features/app-shell/ProjectCreation.tsx @@ -24,6 +24,15 @@ import type { HomeProjectCreationController } from './useHomeProjectCreation'; import type { RecentProjectsController } from './useRecentProjects'; function projectKindLabel(project: RecentProjectRow) { + if (project.projectKind === 'cocos') { + return 'Cocos Creator'; + } + if (project.projectKind === 'unity') { + return 'Unity'; + } + if (project.projectKind === 'ue') { + return 'Unreal Engine'; + } if (project.projectKind === 'godot') { return project.godotProjectRoot && project.godotProjectRoot !== '.' ? `Godot · ${project.godotProjectRoot}` @@ -314,7 +323,8 @@ export function ProjectsPage({ onSubmit={submitRename} > - {project.projectKind === 'godot' ? ( + {project.projectKind === 'godot' || + project.projectKind === 'cocos' ? (

+ {panel.title} + +
+ {error ? ( +

{error}

+ ) : html === null ? ( +

正在加载

+ ) : ( +