mirror of
https://github.com/storytold/craft-anything.git
synced 2026-11-19 14:00:52 +01:00
A local MCP plugin that exited before answering only said "The X plugin exited." It now gives its exit code and the last lines it printed, and a write to a server that has already gone gives the same error. When a local plugin can't be started, exits, or doesn't answer in time, a failure log is written to logs/ in the config folder and named in the error. The plugin's environment is left out of the log, and a remote plugin or a stop writes none. The failure-log writer moves to the engine crate so plugins and agent runs share it.
701 lines
33 KiB
Rust
701 lines
33 KiB
Rust
//! The Craft Anything engine: one session, one registry of tools, one way in.
|
|
//!
|
|
//! The desktop UI, the CLI, the MCP server and the built-in AI agent all call [`Engine::call`]
|
|
//! with a tool id and JSON params. The engine checks availability and consent, runs the tool,
|
|
//! records the evidence it returns, and turns any escaped panic into an error.
|
|
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
|
|
|
|
pub mod clean_room;
|
|
|
|
/// Tools an agent app may be told to approve on its own side (Codex's `approval_mode`): each one
|
|
/// asks the person itself (`Effects::needs_consent`), so approving it there skips nothing.
|
|
/// Everything else keeps the app's own policy; a test in the AI crate checks each is registered
|
|
/// and asks for consent.
|
|
pub const AGENT_APP_PREAPPROVED_TOOLS: &[&str] = &["rebuild_start"];
|
|
pub mod failure_log;
|
|
pub mod feed;
|
|
pub mod inbox;
|
|
pub mod journal;
|
|
pub mod mechanics;
|
|
pub mod outputs;
|
|
pub mod pins;
|
|
pub mod plugins;
|
|
pub mod project;
|
|
pub mod questions;
|
|
pub mod registry;
|
|
pub mod self_test;
|
|
pub mod session;
|
|
pub mod settings;
|
|
pub mod target;
|
|
#[doc(hidden)]
|
|
pub mod testing;
|
|
pub mod tool;
|
|
pub mod tool_list;
|
|
pub mod toolchains;
|
|
pub mod tools;
|
|
pub mod versioned;
|
|
pub mod wasm_plugins;
|
|
pub mod workspace;
|
|
|
|
pub use craft_anything_evidence as evidence;
|
|
pub use registry::Registry;
|
|
pub use session::Session;
|
|
pub use settings::{Mode, Settings};
|
|
pub use target::{Target, TargetKind};
|
|
pub use tool::{AGENT_ENV, Caller, CancelToken, Ctx, Effects, Progress, Requires, ToolOutput, ToolSpec, Toolset};
|
|
|
|
use craft_anything_evidence::{ErrorCode, ToolError};
|
|
use craft_anything_platform::sync::{Mutex, MutexGuard};
|
|
use serde_json::Value;
|
|
use std::sync::PoisonError;
|
|
|
|
/// Whether the caller has the user's consent for a tool that runs code or changes a device.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
|
|
pub enum Consent {
|
|
/// Not asked: the engine refuses consent-gated tools unless the project or settings allow them.
|
|
#[default]
|
|
NotAsked,
|
|
/// The user approved this one call.
|
|
Granted,
|
|
}
|
|
|
|
/// Options for one call.
|
|
pub struct CallOptions<'a> {
|
|
pub caller: Caller,
|
|
pub consent: Consent,
|
|
pub cancel: CancelToken,
|
|
pub progress: &'a tool::ProgressFn,
|
|
}
|
|
|
|
fn no_progress(_: Progress) {}
|
|
|
|
impl CallOptions<'static> {
|
|
pub fn new(caller: Caller) -> Self {
|
|
CallOptions { caller, consent: Consent::NotAsked, cancel: CancelToken::default(), progress: &no_progress }
|
|
}
|
|
}
|
|
|
|
impl<'a> CallOptions<'a> {
|
|
pub fn with_consent(mut self, consent: Consent) -> Self {
|
|
self.consent = consent;
|
|
self
|
|
}
|
|
|
|
pub fn with_cancel(mut self, cancel: CancelToken) -> Self {
|
|
self.cancel = cancel;
|
|
self
|
|
}
|
|
|
|
pub fn with_progress<'b>(self, progress: &'b tool::ProgressFn) -> CallOptions<'b> {
|
|
CallOptions { caller: self.caller, consent: self.consent, cancel: self.cancel, progress }
|
|
}
|
|
}
|
|
|
|
/// Why a tool can't run right now, in words a beginner understands, plus how to fix it.
|
|
#[derive(Debug, Clone, PartialEq, serde::Serialize)]
|
|
pub struct Availability {
|
|
pub available: bool,
|
|
pub reason: Option<String>,
|
|
pub remediation: Option<String>,
|
|
}
|
|
|
|
impl Availability {
|
|
fn ok() -> Self {
|
|
Availability { available: true, reason: None, remediation: None }
|
|
}
|
|
|
|
pub(crate) fn no(reason: impl Into<String>, remediation: impl Into<String>) -> Self {
|
|
Availability { available: false, reason: Some(reason.into()), remediation: Some(remediation.into()) }
|
|
}
|
|
}
|
|
|
|
/// The engine. Cheap to share behind an `Arc`.
|
|
pub struct Engine {
|
|
registry: Registry,
|
|
session: Mutex<Session>,
|
|
/// Sign-in evidence that couldn't reach the ledger because Stop came while another tool held
|
|
/// the session, with the project root it belongs to. Taken in whenever the session is next
|
|
/// locked (see [`Engine::settle`]). Locked only briefly, and never while waiting for the session.
|
|
pending: Mutex<Vec<(Option<std::path::PathBuf>, craft_anything_evidence::Evidence)>>,
|
|
}
|
|
|
|
/// A handle to the engine a tool runs in, for tools that start work which calls back into it (a
|
|
/// rebuild run). Only set on engines made with [`Engine::shared`]; it never keeps the engine alive.
|
|
pub struct EngineRef(pub std::sync::Weak<Engine>);
|
|
|
|
impl Engine {
|
|
pub fn new(session: Session) -> Self {
|
|
Engine { registry: Registry::with_all_tools(), session: Mutex::new(session), pending: Mutex::new(Vec::new()) }
|
|
}
|
|
|
|
/// The engine as most apps use it: shared, with tools from higher layers (`extra`, e.g. the
|
|
/// AI layer's rebuild tools) registered next to the engine's own, and an [`EngineRef`] in the
|
|
/// session so those tools can reach it. A duplicate id keeps the engine's own tool.
|
|
pub fn shared(session: Session, extra: Vec<ToolSpec>) -> std::sync::Arc<Engine> {
|
|
Engine::shared_with(session, extra, Vec::new())
|
|
}
|
|
|
|
/// [`Engine::shared`] plus tools defined at run time (a plugin's, an external MCP server's):
|
|
/// owned names and a JSON schema, served by a function that can tell them apart by
|
|
/// [`Ctx::tool`]. Invalid or duplicate ones are skipped and logged.
|
|
pub fn shared_with(session: Session, extra: Vec<ToolSpec>, runtime: Vec<registry::RuntimeTool>) -> std::sync::Arc<Engine> {
|
|
let mut tools = tools::all();
|
|
tools.extend(extra);
|
|
std::sync::Arc::new_cyclic(|me| {
|
|
let mut session = session;
|
|
session.ext.insert(std::sync::Arc::new(EngineRef(me.clone())));
|
|
Engine { registry: Registry::new(tools).with_runtime(runtime), session: Mutex::new(session), pending: Mutex::new(Vec::new()) }
|
|
})
|
|
}
|
|
|
|
pub fn registry(&self) -> &Registry {
|
|
&self.registry
|
|
}
|
|
|
|
/// Lock the session (recovering from a poisoned lock rather than cascading a panic).
|
|
#[track_caller]
|
|
pub fn session(&self) -> MutexGuard<'_, Session> {
|
|
let mut session = self.session.lock().unwrap_or_else(PoisonError::into_inner);
|
|
self.settle(&mut session);
|
|
session
|
|
}
|
|
|
|
/// Try to lock without blocking (the UI uses this so a long tool never freezes a frame).
|
|
#[track_caller]
|
|
pub fn try_session(&self) -> Option<MutexGuard<'_, Session>> {
|
|
let mut session = match self.session.try_lock() {
|
|
Ok(g) => g,
|
|
Err(std::sync::TryLockError::Poisoned(p)) => p.into_inner(),
|
|
Err(std::sync::TryLockError::WouldBlock) => return None,
|
|
};
|
|
self.settle(&mut session);
|
|
Some(session)
|
|
}
|
|
|
|
/// Take pending sign-in evidence into `session`'s ledger when it belongs to the project open
|
|
/// now (or to no project, with none open). Evidence for another project is already in that
|
|
/// project's store, so it's dropped from memory here, not recorded in the wrong ledger.
|
|
fn settle(&self, session: &mut Session) {
|
|
let pending = std::mem::take(&mut *self.pending.lock().unwrap_or_else(PoisonError::into_inner));
|
|
let open = session.project.as_ref().map(|p| p.root.clone());
|
|
for (root, ev) in pending {
|
|
if root == open
|
|
&& let Err(e) = session.record(ev)
|
|
{
|
|
log::warn!("couldn't record a stopped sign-in's evidence: {}", e.message);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn availability(&self, spec: &ToolSpec, session: &Session) -> Availability {
|
|
if let Some(no) = clean_room::availability(spec.id, session.clean_room()) {
|
|
return no;
|
|
}
|
|
match spec.requires {
|
|
Requires::Nothing => Availability::ok(),
|
|
Requires::Target => {
|
|
if session.active_id().is_some() {
|
|
Availability::ok()
|
|
} else {
|
|
Availability::no("Nothing is open yet.", "Open a file, app or folder first.")
|
|
}
|
|
}
|
|
Requires::Ghidra => {
|
|
if !session.clean_room() {
|
|
Availability::ok()
|
|
} else {
|
|
Availability::no("This needs Deep mode (with Ghidra), and you're in Clean room mode.", "Turn on Deep mode in the title bar or Settings.")
|
|
}
|
|
}
|
|
Requires::Engine(id) => match session.settings.engine_path(id) {
|
|
Some(_) => Availability::ok(),
|
|
None => {
|
|
let (reason, remediation) = session.settings.engine_not_found(id);
|
|
Availability::no(reason, remediation)
|
|
}
|
|
},
|
|
Requires::Os(hosts) => {
|
|
if hosts.contains(&std::env::consts::OS) {
|
|
Availability::ok()
|
|
} else {
|
|
let names = hosts.iter().map(|h| match *h {
|
|
"macos" => "macOS",
|
|
"windows" => "Windows",
|
|
"linux" => "Linux",
|
|
other => other,
|
|
});
|
|
let names = names.collect::<Vec<_>>().join(" or ");
|
|
Availability::no(
|
|
format!("This needs {names} and is not available on this host ({}).", craft_anything_evidence::host_triple()),
|
|
format!("Run it on {names}."),
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Run a tool by id. When a project is open, the call is appended to its journal.
|
|
pub fn call(&self, id: &str, params: Value, opts: CallOptions<'_>) -> Result<ToolOutput, ToolError> {
|
|
let started = std::time::Instant::now();
|
|
let logged_params = journal::bounded(¶ms);
|
|
let caller = opts.caller;
|
|
let mut journal_at = JournalAt::Live;
|
|
let result = self.call_inner(id, params, opts, &mut journal_at);
|
|
let outcome = match &result {
|
|
Ok(ToolOutput::Evidence(ev)) => serde_json::json!({"ok": true, "evidence_id": ev.id}),
|
|
Ok(ToolOutput::Value(_)) => serde_json::json!({"ok": true}),
|
|
Err(e) => serde_json::json!({"ok": false, "error_code": e.code, "error": e.message}),
|
|
};
|
|
let mut entry = serde_json::json!({"tool": id, "caller": caller, "params": logged_params, "duration_ms": started.elapsed().as_millis() as u64});
|
|
if let (Some(m), serde_json::Value::Object(o)) = (entry.as_object_mut(), outcome) {
|
|
m.extend(o);
|
|
}
|
|
match journal_at {
|
|
JournalAt::Live => self.journal("tool_call", entry),
|
|
// Written without the session: the call may have been stopped while another tool holds it.
|
|
JournalAt::Project(Some(root)) => journal::append(&root, "tool_call", entry),
|
|
JournalAt::Project(None) => {}
|
|
}
|
|
result
|
|
}
|
|
|
|
/// Append an entry to the open project's journal (no-op without a project). Never fails.
|
|
pub fn journal(&self, kind: &str, entry: Value) {
|
|
let root = self.session().project.as_ref().map(|p| p.root.clone());
|
|
if let Some(root) = root {
|
|
journal::append(&root, kind, entry);
|
|
}
|
|
}
|
|
|
|
fn call_inner(&self, id: &str, params: Value, opts: CallOptions<'_>, journal_at: &mut JournalAt) -> Result<ToolOutput, ToolError> {
|
|
let spec = *self.registry.get(id).ok_or_else(|| {
|
|
ToolError::invalid(format!("No tool named {id}")).with_remediation("List tools with `craft-anything-cli commands` or the command palette.")
|
|
})?;
|
|
// Stop works while waiting for the session, and a holder that looks stuck is an error here,
|
|
// not a wait forever. Tools are long jobs: the label says so (they have their own deadlines).
|
|
let cancel = opts.cancel.clone();
|
|
let mut session = match self.session.lock_unless(&|| cancel.is_cancelled()) {
|
|
Ok(g) => {
|
|
let mut g = g.unwrap_or_else(PoisonError::into_inner);
|
|
self.settle(&mut g);
|
|
g
|
|
}
|
|
Err(craft_anything_platform::sync::GaveUp::Stopped) => return Err(ToolError::cancelled()),
|
|
Err(craft_anything_platform::sync::GaveUp::Stuck(why)) => {
|
|
return Err(ToolError::new(ErrorCode::TimedOut, format!("{} couldn't start because another part of the app is stuck.", spec.title))
|
|
.with_remediation("Restart the app; your work is kept.")
|
|
.with_details(serde_json::json!({"lock": why})));
|
|
}
|
|
};
|
|
session.label(spec.id);
|
|
if session.clean_room() && !clean_room::allows(spec.id) {
|
|
return Err(clean_room::refusal(spec.id));
|
|
}
|
|
let avail = self.availability(&spec, &session);
|
|
if !avail.available {
|
|
let code = match spec.requires {
|
|
Requires::Target => ErrorCode::NotFound,
|
|
// A missing external engine (adb, frida, …) is a provider problem, not a capability
|
|
// the build lacks; agents branch on this to offer an install.
|
|
Requires::Engine(_) => ErrorCode::EngineMissing,
|
|
_ => ErrorCode::FeatureMissing,
|
|
};
|
|
let mut err = ToolError::new(code, avail.reason.unwrap_or_default());
|
|
err.remediation = avail.remediation;
|
|
if matches!(spec.requires, Requires::Os(_)) {
|
|
err = err.with_details(serde_json::json!({"reason": "wrong_os", "tool": spec.id}));
|
|
}
|
|
return Err(err);
|
|
}
|
|
if spec.effects.needs_consent() && opts.consent != Consent::Granted {
|
|
let allowed = !session.settings.ask_before_running || session.project.as_ref().is_some_and(|p| p.is_allowed(spec.id));
|
|
if !allowed {
|
|
return Err(ToolError::new(ErrorCode::ConsentRequired, format!("{} runs code or changes a device, so it needs your OK first.", spec.title))
|
|
.with_remediation("Approve it when asked, or allow it for this project in Settings.")
|
|
.with_details(serde_json::json!({"tool": spec.id})));
|
|
}
|
|
}
|
|
let run = spec.run;
|
|
let invoke = |session: &mut Session| {
|
|
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
|
|
let mut ctx = Ctx { tool: spec.id, session, cancel: opts.cancel.clone(), progress: opts.progress, caller: opts.caller };
|
|
run(&mut ctx, params)
|
|
}))
|
|
};
|
|
if spec.id == tools::site_sign_in::SIGN_IN_TOOL {
|
|
// Sign-in needs launch settings, not exclusive access to the person's live session.
|
|
let mut isolated = Session::isolated(&session.config_dir());
|
|
isolated.settings = session.settings.clone();
|
|
isolated.deep_for_run = session.deep_for_run;
|
|
// The window may stay open while the person opens another project: what it saved
|
|
// belongs to the project it was started from.
|
|
let started_in = session.project.clone();
|
|
*journal_at = JournalAt::Project(started_in.as_ref().map(|p| p.root.clone()));
|
|
drop(session);
|
|
let output = Self::finished(spec.id, spec.title, invoke(&mut isolated))?;
|
|
self.record_sign_in(spec.id, &output, started_in.as_ref(), &cancel)?;
|
|
return Ok(output);
|
|
}
|
|
let output = Self::finished(spec.id, spec.title, invoke(&mut session))?;
|
|
if let ToolOutput::Evidence(ev) = &output {
|
|
session.record((**ev).clone())?;
|
|
}
|
|
Ok(output)
|
|
}
|
|
|
|
/// A tool's own result, or its panic as an error (logged) instead of a crash.
|
|
fn finished(id: &str, title: &str, result: std::thread::Result<Result<ToolOutput, ToolError>>) -> Result<ToolOutput, ToolError> {
|
|
match result {
|
|
Ok(r) => r,
|
|
Err(panic) => {
|
|
let what = panic.downcast_ref::<&str>().map(|s| s.to_string()).or_else(|| panic.downcast_ref::<String>().cloned()).unwrap_or_default();
|
|
log::error!("tool {id} panicked: {what}");
|
|
Err(ToolError::internal(format!("{title} hit a bug and stopped safely. Your work is kept. ({what})")))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Record a finished sign-in's evidence in the project it started in. The live session is
|
|
/// waited for only until Stop; then, or when another project is open by now, the evidence goes
|
|
/// straight to the starting project's store, so a saved profile is never left unrecorded.
|
|
fn record_sign_in(&self, tool: &'static str, output: &ToolOutput, started_in: Option<&project::Project>, cancel: &CancelToken) -> Result<(), ToolError> {
|
|
let ToolOutput::Evidence(ev) = output else { return Ok(()) };
|
|
let root = started_in.map(|p| &p.root);
|
|
if let Ok(guard) = self.session.lock_unless(&|| cancel.is_cancelled()) {
|
|
let mut session = guard.unwrap_or_else(PoisonError::into_inner);
|
|
self.settle(&mut session);
|
|
session.label(tool);
|
|
if session.project.as_ref().map(|p| &p.root) == root {
|
|
return session.record((**ev).clone());
|
|
}
|
|
// Another project is open now: its ledger isn't where this belongs.
|
|
return started_in.map_or(Ok(()), |project| project.store_evidence(ev));
|
|
}
|
|
// Stopped while another tool holds the session: keep it on disk now and in the ledger later.
|
|
if let Some(project) = started_in {
|
|
project.store_evidence(ev)?;
|
|
}
|
|
self.pending.lock().unwrap_or_else(PoisonError::into_inner).push((root.cloned(), (**ev).clone()));
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// Where [`Engine::call`] journals a call: the live session's project, or one fixed when the call
|
|
/// started (a sign-in that ran without holding the session).
|
|
enum JournalAt {
|
|
Live,
|
|
Project(Option<std::path::PathBuf>),
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
/// Replace only the browser callback; authorization and dispatch remain the real path.
|
|
fn sign_in_engine(run: tool::ToolFn) -> std::sync::Arc<Engine> {
|
|
let mut session = crate::testing::session();
|
|
session.settings.engines.tools.chromium = Some(std::env::current_exe().unwrap());
|
|
let mut specs = tools::all();
|
|
specs.iter_mut().find(|s| s.id == tools::site_sign_in::SIGN_IN_TOOL).unwrap().run = run;
|
|
std::sync::Arc::new(Engine { registry: Registry::new(specs), session: Mutex::new(session), pending: Mutex::new(Vec::new()) })
|
|
}
|
|
|
|
#[test]
|
|
fn sign_in_wait_leaves_session_available_and_records_even_after_stop() {
|
|
use std::sync::{
|
|
Arc,
|
|
atomic::{AtomicBool, Ordering},
|
|
mpsc,
|
|
};
|
|
use std::time::{Duration, Instant};
|
|
fn waiting(ctx: &mut Ctx<'_>, _: Value) -> Result<ToolOutput, ToolError> {
|
|
assert!(ctx.session.settings.deep_mode);
|
|
assert!(ctx.session.settings.engines.tools.chromium.is_some());
|
|
assert!(ctx.session.project.is_none());
|
|
assert!(ctx.session.ext.get::<EngineRef>().is_none());
|
|
ctx.report(None, "waiting for the person");
|
|
assert!(ctx.cancel.is_cancelled());
|
|
ctx.session.settings.deep_mode = false;
|
|
let forget = tools::site_sign_in::specs().into_iter().find(|s| s.id == tools::site_sign_in::SIGN_OUT_TOOL).unwrap();
|
|
(forget.run)(ctx, serde_json::json!({"url": "https://example.com"}))
|
|
}
|
|
let e = sign_in_engine(waiting);
|
|
let config = e.session().config_dir();
|
|
let release = Arc::new(AtomicBool::new(false));
|
|
let gate = release.clone();
|
|
let (started, entered) = mpsc::channel();
|
|
let cancel = CancelToken::default();
|
|
let stop = cancel.clone();
|
|
let worker = e.clone();
|
|
let sign_in = std::thread::spawn(move || {
|
|
let progress = move |_: Progress| {
|
|
started.send(()).unwrap();
|
|
let deadline = Instant::now() + Duration::from_secs(10);
|
|
while !gate.load(Ordering::Acquire) && Instant::now() < deadline {
|
|
std::thread::park_timeout(Duration::from_millis(5));
|
|
}
|
|
};
|
|
worker.call(
|
|
tools::site_sign_in::SIGN_IN_TOOL,
|
|
Value::Null,
|
|
CallOptions::new(Caller::Cli).with_consent(Consent::Granted).with_cancel(cancel).with_progress(&progress),
|
|
)
|
|
});
|
|
let waiting = entered.recv_timeout(Duration::from_secs(5));
|
|
let worker = e.clone();
|
|
let (sent, received) = mpsc::channel();
|
|
let other = std::thread::spawn(move || {
|
|
let result = worker.call("core_session_show", Value::Null, CallOptions::new(Caller::Cli));
|
|
let _ = sent.send(result);
|
|
});
|
|
let concurrent = received.recv_timeout(Duration::from_secs(2));
|
|
stop.cancel();
|
|
release.store(true, Ordering::Release);
|
|
let output = sign_in.join().unwrap().unwrap();
|
|
other.join().unwrap();
|
|
waiting.unwrap();
|
|
concurrent.expect("another tool must complete before sign-in is released").unwrap();
|
|
let ToolOutput::Evidence(ev) = output else { panic!("expected saved evidence") };
|
|
let session = e.session();
|
|
assert_eq!(session.config_dir(), config);
|
|
assert!(session.settings.deep_mode, "the snapshot must not overwrite live settings");
|
|
assert_eq!(session.ledger().filter(|record| record.id == ev.id).count(), 1);
|
|
}
|
|
|
|
/// A sign-in held at its window until `gate` opens; it then returns sign-out evidence.
|
|
fn gated_sign_in(
|
|
e: &std::sync::Arc<Engine>,
|
|
cancel: CancelToken,
|
|
gate: std::sync::Arc<std::sync::atomic::AtomicBool>,
|
|
) -> (std::thread::JoinHandle<Result<ToolOutput, ToolError>>, std::sync::mpsc::Receiver<()>) {
|
|
let (started, entered) = std::sync::mpsc::channel();
|
|
let worker = e.clone();
|
|
let handle = std::thread::spawn(move || {
|
|
let progress = move |_: Progress| {
|
|
let _ = started.send(());
|
|
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
|
|
while !gate.load(std::sync::atomic::Ordering::Acquire) && std::time::Instant::now() < deadline {
|
|
std::thread::park_timeout(std::time::Duration::from_millis(5));
|
|
}
|
|
};
|
|
worker.call(
|
|
tools::site_sign_in::SIGN_IN_TOOL,
|
|
Value::Null,
|
|
CallOptions::new(Caller::Cli).with_consent(Consent::Granted).with_cancel(cancel).with_progress(&progress),
|
|
)
|
|
});
|
|
(handle, entered)
|
|
}
|
|
|
|
fn signs_out(ctx: &mut Ctx<'_>, _: Value) -> Result<ToolOutput, ToolError> {
|
|
ctx.report(None, "waiting for the person");
|
|
let forget = tools::site_sign_in::specs().into_iter().find(|s| s.id == tools::site_sign_in::SIGN_OUT_TOOL).unwrap();
|
|
(forget.run)(ctx, serde_json::json!({"url": "https://example.com"}))
|
|
}
|
|
|
|
fn journalled_sign_ins(root: &std::path::Path) -> usize {
|
|
journal::days(root)
|
|
.iter()
|
|
.flat_map(|d| journal::read_day(root, d))
|
|
.filter(|entry| entry.to_string().contains(tools::site_sign_in::SIGN_IN_TOOL))
|
|
.count()
|
|
}
|
|
|
|
/// Review of #1459: another project opened while the window is open doesn't get the sign-in's record.
|
|
#[test]
|
|
fn sign_in_records_in_the_project_it_started_in() {
|
|
use std::sync::{Arc, atomic::AtomicBool};
|
|
let dirs = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());
|
|
let a = project::Project::create(&dirs.0.path().join("a"), "A", project::Purpose::default()).unwrap();
|
|
let b = project::Project::create(&dirs.1.path().join("b"), "B", project::Purpose::default()).unwrap();
|
|
let e = sign_in_engine(signs_out);
|
|
e.session().project = Some(a.clone());
|
|
let gate = Arc::new(AtomicBool::new(false));
|
|
let (sign_in, entered) = gated_sign_in(&e, CancelToken::default(), gate.clone());
|
|
entered.recv_timeout(std::time::Duration::from_secs(5)).unwrap();
|
|
e.session().project = Some(b.clone());
|
|
gate.store(true, std::sync::atomic::Ordering::Release);
|
|
let ToolOutput::Evidence(ev) = sign_in.join().unwrap().unwrap() else { panic!("expected evidence") };
|
|
assert!(a.load_evidence(&ev.id).is_ok(), "the starting project keeps the record");
|
|
assert!(b.load_evidence(&ev.id).is_err(), "the project opened meanwhile doesn't get it");
|
|
assert!(e.session().evidence(&ev.id).is_none(), "nor its ledger");
|
|
assert_eq!((journalled_sign_ins(&a.root), journalled_sign_ins(&b.root)), (1, 0));
|
|
}
|
|
|
|
/// Review of #1459: Stop ends the wait for a session another tool holds; the record is still kept.
|
|
#[test]
|
|
fn a_stopped_sign_in_does_not_wait_for_a_busy_session_and_keeps_its_record() {
|
|
use std::sync::{Arc, atomic::AtomicBool};
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let a = project::Project::create(&dir.path().join("a"), "A", project::Purpose::default()).unwrap();
|
|
for with_project in [true, false] {
|
|
let e = sign_in_engine(signs_out);
|
|
if with_project {
|
|
e.session().project = Some(a.clone());
|
|
}
|
|
let gate = Arc::new(AtomicBool::new(false));
|
|
let cancel = CancelToken::default();
|
|
let (sign_in, entered) = gated_sign_in(&e, cancel.clone(), gate.clone());
|
|
entered.recv_timeout(std::time::Duration::from_secs(5)).unwrap();
|
|
let busy = e.session();
|
|
cancel.cancel();
|
|
gate.store(true, std::sync::atomic::Ordering::Release);
|
|
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
|
|
while !sign_in.is_finished() && std::time::Instant::now() < deadline {
|
|
std::thread::sleep(std::time::Duration::from_millis(5));
|
|
}
|
|
let finished = sign_in.is_finished();
|
|
drop(busy);
|
|
assert!(finished, "a stopped sign-in must not wait for the session (project: {with_project})");
|
|
let ToolOutput::Evidence(ev) = sign_in.join().unwrap().unwrap() else { panic!("expected evidence") };
|
|
if with_project {
|
|
assert!(a.load_evidence(&ev.id).is_ok(), "the saved profile's evidence is kept");
|
|
assert_eq!(journalled_sign_ins(&a.root), 1);
|
|
}
|
|
// Once the other tool lets go, the ledger has it too, once.
|
|
let session = e.session();
|
|
assert_eq!(session.ledger().filter(|r| r.id == ev.id).count(), 1, "project: {with_project}");
|
|
}
|
|
}
|
|
|
|
/// A stopped sign-in's evidence waits for the project it started in, never another one.
|
|
#[test]
|
|
fn pending_sign_in_evidence_reaches_only_its_own_ledger() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let a = project::Project::create(&dir.path().join("a"), "A", project::Purpose::default()).unwrap();
|
|
let e = sign_in_engine(signs_out);
|
|
let mut s = crate::testing::session();
|
|
let ToolOutput::Evidence(ev) = signs_out(
|
|
&mut Ctx { tool: tools::site_sign_in::SIGN_IN_TOOL, session: &mut s, cancel: CancelToken::default(), progress: &no_progress, caller: Caller::Cli },
|
|
Value::Null,
|
|
)
|
|
.unwrap() else {
|
|
panic!("expected evidence")
|
|
};
|
|
e.pending.lock().unwrap().push((Some(a.root.clone()), (*ev).clone()));
|
|
assert!(e.session().evidence(&ev.id).is_none(), "no project is open: not this ledger");
|
|
assert!(e.pending.lock().unwrap().is_empty(), "and it isn't kept waiting forever");
|
|
e.session().project = Some(a.clone());
|
|
e.pending.lock().unwrap().push((Some(a.root.clone()), (*ev).clone()));
|
|
assert!(e.session().evidence(&ev.id).is_some(), "its own project is open: recorded");
|
|
}
|
|
|
|
#[test]
|
|
fn isolated_sign_in_still_requires_consent_and_contains_panics() {
|
|
fn broken(_: &mut Ctx<'_>, _: Value) -> Result<ToolOutput, ToolError> {
|
|
panic!("stand-in browser bug");
|
|
}
|
|
let e = sign_in_engine(broken);
|
|
let refused = e.call(tools::site_sign_in::SIGN_IN_TOOL, Value::Null, CallOptions::new(Caller::Cli)).unwrap_err();
|
|
assert_eq!(refused.code, ErrorCode::ConsentRequired);
|
|
let failed = e.call(tools::site_sign_in::SIGN_IN_TOOL, Value::Null, CallOptions::new(Caller::Cli).with_consent(Consent::Granted)).unwrap_err();
|
|
assert_eq!(failed.code, ErrorCode::Internal);
|
|
assert!(e.call("core_session_show", Value::Null, CallOptions::new(Caller::Cli)).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn unknown_tool_is_an_error_not_a_panic() {
|
|
let e = Engine::new(crate::testing::session());
|
|
let err = e.call("no_such_tool", Value::Null, CallOptions::new(Caller::Cli)).unwrap_err();
|
|
assert_eq!(err.code, ErrorCode::BadInput);
|
|
}
|
|
|
|
/// #841: Try again repeated "install a browser" for a person who had set a path to theirs.
|
|
#[test]
|
|
fn a_tool_says_when_the_path_set_for_its_engine_is_not_there() {
|
|
let mut session = crate::testing::session();
|
|
session.settings.engines.tools.chromium = Some("/nowhere/brave".into());
|
|
let e = Engine::new(session);
|
|
let err = e.call("web_site_open", serde_json::json!({"url": "https://example.com"}), CallOptions::new(Caller::Cli)).unwrap_err();
|
|
assert_eq!(err.code, ErrorCode::EngineMissing);
|
|
assert!(err.message.contains("isn't there") && err.message.contains("brave"), "{}", err.message);
|
|
}
|
|
|
|
#[test]
|
|
fn every_engine_a_tool_needs_is_in_the_engine_table() {
|
|
let e = Engine::new(crate::testing::session());
|
|
for spec in e.registry().all() {
|
|
if let Requires::Engine(id) = spec.requires {
|
|
assert!(craft_anything_engines::engine(id).is_some(), "{} needs unknown engine {id:?}", spec.id);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn target_tools_explain_what_to_do() {
|
|
let e = Engine::new(crate::testing::session());
|
|
let err = e.call("native_cursor_show", Value::Null, CallOptions::new(Caller::Mcp)).unwrap_err();
|
|
assert_eq!(err.code, ErrorCode::NotFound);
|
|
assert!(err.remediation.is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn higher_layers_add_tools_and_reach_the_engine() {
|
|
fn whoami(ctx: &mut Ctx<'_>, _: Value) -> Result<ToolOutput, ToolError> {
|
|
let alive = ctx.session.ext.get::<EngineRef>().and_then(|r| r.0.upgrade()).is_some();
|
|
Ok(ToolOutput::Value(serde_json::json!({"engine": alive})))
|
|
}
|
|
let extra = ToolSpec {
|
|
id: "test_whoami",
|
|
title: "Who am I",
|
|
summary: "Test tool.",
|
|
beginner: "Test tool.",
|
|
toolset: Toolset::Core,
|
|
effects: Effects::READ_ONLY,
|
|
requires: Requires::Nothing,
|
|
input_schema: tool::empty_schema,
|
|
run: whoami,
|
|
};
|
|
let e = Engine::shared(crate::testing::session(), vec![extra]);
|
|
assert!(e.registry().get("core_target_triage").is_some(), "the engine's own tools are still there");
|
|
let out = e.call("test_whoami", Value::Null, CallOptions::new(Caller::Cli)).unwrap().to_json();
|
|
assert_eq!(out["result"]["engine"], true);
|
|
}
|
|
|
|
#[test]
|
|
fn tools_defined_at_run_time_get_their_own_schema_group_and_id() {
|
|
use registry::{RuntimeTool, custom_toolset};
|
|
fn echo(ctx: &mut Ctx<'_>, params: Value) -> Result<ToolOutput, ToolError> {
|
|
Ok(ToolOutput::Value(serde_json::json!({"tool": ctx.tool, "params": params})))
|
|
}
|
|
let group = custom_toolset("demo_plugin").unwrap();
|
|
let tool = |id: &str, schema: Value| RuntimeTool {
|
|
id: id.into(),
|
|
title: format!("Demo {id}"),
|
|
summary: "A demo tool.".into(),
|
|
beginner: "A demo tool.".into(),
|
|
toolset: group,
|
|
effects: Effects::READ_ONLY,
|
|
requires: Requires::Nothing,
|
|
schema,
|
|
run: echo,
|
|
};
|
|
let schema = serde_json::json!({"type": "object", "properties": {"word": {"type": "string"}}});
|
|
let e = Engine::shared_with(
|
|
crate::testing::session(),
|
|
Vec::new(),
|
|
vec![
|
|
tool("demo_one", schema.clone()),
|
|
tool("demo_two", schema.clone()),
|
|
tool("Bad Id", schema.clone()),
|
|
tool("core_target_triage", schema.clone()),
|
|
tool("demo_three", serde_json::json!("not an object")),
|
|
],
|
|
);
|
|
let r = e.registry();
|
|
assert!(r.get("demo_one").is_some() && r.get("demo_two").is_some());
|
|
assert!(r.get("demo_three").is_none(), "a schema must be an object");
|
|
assert_ne!(r.get("core_target_triage").map(|s| s.title), Some("Demo core_target_triage"), "an engine tool keeps its id");
|
|
assert!(r.get("bad_id").is_none());
|
|
// One function serves both; it knows which was called.
|
|
let out = e.call("demo_two", serde_json::json!({"word": "hi"}), CallOptions::new(Caller::Cli)).unwrap().to_json();
|
|
assert_eq!(out["result"]["tool"], "demo_two");
|
|
let spec = *r.get("demo_one").unwrap();
|
|
assert_eq!(r.mcp_descriptor(&spec)["inputSchema"], schema);
|
|
assert!(r.toolsets().contains(&group) && r.toolset("demo_plugin") == Some(group));
|
|
assert_eq!(serde_json::to_value(group).unwrap(), "demo_plugin");
|
|
assert!(custom_toolset("No Spaces").is_none());
|
|
assert_eq!(custom_toolset("core"), Some(Toolset::Core), "a built-in id is the built-in group");
|
|
}
|
|
}
|