@team-agent/installer 0.5.127 → 0.5.128
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/Cargo.lock +1 -1
- package/Cargo.toml +1 -1
- package/README.md +11 -0
- package/crates/team-agent/src/cli/adapters.rs +3 -13
- package/crates/team-agent/src/cli/arguments.rs +4 -0
- package/crates/team-agent/src/cli/diagnose.rs +68 -22
- package/crates/team-agent/src/cli/emit.rs +58 -26
- package/crates/team-agent/src/cli/intent/runtime.rs +32 -5
- package/crates/team-agent/src/cli/intent/runtime_tests.rs +102 -11
- package/crates/team-agent/src/cli/intent/tests.rs +10 -12
- package/crates/team-agent/src/cli/intent.rs +1 -1
- package/crates/team-agent/src/cli/mod.rs +25 -8
- package/crates/team-agent/src/cli/models.rs +764 -7
- package/crates/team-agent/src/cli/schedule.rs +175 -0
- package/crates/team-agent/src/cli/send/persist.rs +0 -36
- package/crates/team-agent/src/cli/send/presentation.rs +1 -1
- package/crates/team-agent/src/cli/send.rs +108 -110
- package/crates/team-agent/src/cli/spec.rs +6 -0
- package/crates/team-agent/src/cli/status_port/brief.rs +5 -67
- package/crates/team-agent/src/cli/tests/leader_watch.rs +12 -62
- package/crates/team-agent/src/cli/tests/mod.rs +1 -1
- package/crates/team-agent/src/cli/tests/named_address.rs +11 -10
- package/crates/team-agent/src/cli/tests/run_delegation.rs +9 -6
- package/crates/team-agent/src/cli/tests/status_send.rs +68 -271
- package/crates/team-agent/src/compiler/tests.rs +3 -18
- package/crates/team-agent/src/compiler.rs +205 -6
- package/crates/team-agent/src/contract_runtime/backend.rs +145 -11
- package/crates/team-agent/src/contract_runtime/commands.rs +7 -7
- package/crates/team-agent/src/contract_runtime/config.rs +26 -16
- package/crates/team-agent/src/contract_runtime/config_tests.rs +24 -4
- package/crates/team-agent/src/contract_runtime/discovery.rs +12 -1
- package/crates/team-agent/src/contract_runtime/fork.rs +3 -10
- package/crates/team-agent/src/contract_runtime/framework.rs +28 -11
- package/crates/team-agent/src/contract_runtime/mcp.rs +19 -24
- package/crates/team-agent/src/contract_runtime/prompt.rs +2 -2
- package/crates/team-agent/src/contract_runtime/registry.rs +56 -92
- package/crates/team-agent/src/coordinator/steps/abnormal.rs +11 -11
- package/crates/team-agent/src/coordinator/tests/api_error_recovery.rs +16 -54
- package/crates/team-agent/src/coordinator/tests/health_sync.rs +42 -0
- package/crates/team-agent/src/coordinator/tick.rs +1 -89
- package/crates/team-agent/src/db/message_store.rs +7 -65
- package/crates/team-agent/src/direct_delivery.rs +368 -0
- package/crates/team-agent/src/inbox_store.rs +169 -0
- package/crates/team-agent/src/leader/registry.rs +5 -0
- package/crates/team-agent/src/leader/start.rs +2 -1
- package/crates/team-agent/src/leader/tests/lease_api.rs +2 -2
- package/crates/team-agent/src/leader/tests/prompt_contract.rs +1 -0
- package/crates/team-agent/src/lib.rs +2 -0
- package/crates/team-agent/src/lifecycle/launch/add_agent.rs +33 -0
- package/crates/team-agent/src/lifecycle/launch/add_agent_state.rs +206 -1
- package/crates/team-agent/src/lifecycle/launch/clone_agent.rs +28 -2
- package/crates/team-agent/src/lifecycle/launch/fork_agent.rs +38 -13
- package/crates/team-agent/src/lifecycle/launch/fork_entry.rs +87 -6
- package/crates/team-agent/src/lifecycle/launch/mcp_config.rs +9 -1
- package/crates/team-agent/src/lifecycle/launch/pi_mcp.rs +351 -81
- package/crates/team-agent/src/lifecycle/launch/pi_mcp_extension.js +3 -4
- package/crates/team-agent/src/lifecycle/launch/quick_start.rs +24 -0
- package/crates/team-agent/src/lifecycle/launch/spawn.rs +36 -13
- package/crates/team-agent/src/lifecycle/launch.rs +24 -1
- package/crates/team-agent/src/lifecycle/profile_launch.rs +321 -11
- package/crates/team-agent/src/lifecycle/restart/agent.rs +1 -0
- package/crates/team-agent/src/lifecycle/restart/avatar.rs +1798 -0
- package/crates/team-agent/src/lifecycle/restart/claude_fork.rs +163 -0
- package/crates/team-agent/src/lifecycle/restart/common.rs +345 -35
- package/crates/team-agent/src/lifecycle/restart/selection.rs +5 -5
- package/crates/team-agent/src/lifecycle/restart.rs +4 -0
- package/crates/team-agent/src/lifecycle/role_config.rs +39 -14
- package/crates/team-agent/src/lifecycle/tests/claude_compatible_config_red.rs +325 -0
- package/crates/team-agent/src/lifecycle/tests/claude_profile_launch_red.rs +320 -8
- package/crates/team-agent/src/lifecycle/tests/cli_argv_routing_red.rs +236 -13
- package/crates/team-agent/src/lifecycle/tests/clone_fork_copilot_perms_red.rs +378 -4
- package/crates/team-agent/src/lifecycle/tests/communication_mode_runtime_contract_red.rs +5 -4
- package/crates/team-agent/src/lifecycle/tests/copilot_provider_red.rs +7 -11
- package/crates/team-agent/src/lifecycle/tests/core.rs +47 -18
- package/crates/team-agent/src/lifecycle/tests/fixtures/pi_native_mcp_host.mjs +2 -1
- package/crates/team-agent/src/lifecycle/tests/grok_require_explicit_model_red.rs +14 -14
- package/crates/team-agent/src/lifecycle/tests/harvest2_a_batch_red.rs +60 -20
- package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs +28 -26
- package/crates/team-agent/src/lifecycle/tests/mcp_tool_name_format_red.rs +6 -6
- package/crates/team-agent/src/lifecycle/tests/pi_catalog_red.rs +18 -6
- package/crates/team-agent/src/lifecycle/tests/pi_command_red.rs +70 -52
- package/crates/team-agent/src/lifecycle/tests/pi_compiler_red.rs +210 -0
- package/crates/team-agent/src/lifecycle/tests/pi_dual_entry_red.rs +157 -4
- package/crates/team-agent/src/lifecycle/tests/pi_executable_mcp_red.rs +526 -10
- package/crates/team-agent/src/lifecycle/tests/pi_fork_session_inheritance_red.rs +1419 -0
- package/crates/team-agent/src/lifecycle/tests/pi_lifecycle_doctor_red.rs +68 -1
- package/crates/team-agent/src/lifecycle/tests/pi_native_mcp_capability_red.rs +34 -12
- package/crates/team-agent/src/lifecycle/tests/pi_session_delivery_red.rs +94 -2
- package/crates/team-agent/src/lifecycle/tests/quick_start_worker_readiness_red.rs +10 -11
- package/crates/team-agent/src/lifecycle/tests/status_credential_redaction_contract.rs +2 -2
- package/crates/team-agent/src/lifecycle/tests/swallow_batch4_semantics_red.rs +254 -2
- package/crates/team-agent/src/lifecycle/tests/upgrade_compat_0211_red.rs +4 -4
- package/crates/team-agent/src/lifecycle/tests/verify_rs031_window_consistency_red.rs +5 -6
- package/crates/team-agent/src/lifecycle/tests/worker_spawn_env_red.rs +16 -7
- package/crates/team-agent/src/lifecycle/tests.rs +3 -0
- package/crates/team-agent/src/lifecycle/types.rs +18 -2
- package/crates/team-agent/src/lifecycle/worker_command_context.rs +43 -50
- package/crates/team-agent/src/mcp_server/readiness.rs +130 -149
- package/crates/team-agent/src/mcp_server/readiness_tests.rs +98 -119
- package/crates/team-agent/src/mcp_server/tests/scoped.rs +21 -31
- package/crates/team-agent/src/mcp_server/tests/send.rs +72 -107
- package/crates/team-agent/src/mcp_server/tests/tools.rs +10 -12
- package/crates/team-agent/src/mcp_server/tools.rs +70 -196
- package/crates/team-agent/src/messaging/delivery.rs +160 -218
- package/crates/team-agent/src/messaging/delivery_consumption_tests.rs +5 -5
- package/crates/team-agent/src/messaging/helpers.rs +1 -19
- package/crates/team-agent/src/messaging/mod.rs +1 -0
- package/crates/team-agent/src/messaging/reminders.rs +316 -0
- package/crates/team-agent/src/messaging/scheduler.rs +7 -1
- package/crates/team-agent/src/messaging/tests/dup_inject.rs +191 -85
- package/crates/team-agent/src/messaging/tests/runtime.rs +4 -110
- package/crates/team-agent/src/messaging/tests/spine.rs +40 -24
- package/crates/team-agent/src/messaging/types.rs +1 -0
- package/crates/team-agent/src/provider/adapter.rs +303 -51
- package/crates/team-agent/src/provider/adapters/claude.rs +78 -0
- package/crates/team-agent/src/provider/adapters/claude_fork.rs +131 -0
- package/crates/team-agent/src/provider/adapters/mod.rs +7 -5
- package/crates/team-agent/src/provider/adapters/pi.rs +106 -0
- package/crates/team-agent/src/provider/classify.rs +1 -66
- package/crates/team-agent/src/provider/model_catalog.rs +201 -13
- package/crates/team-agent/src/provider/session/capture.rs +106 -6
- package/crates/team-agent/src/provider/session/context_fork/claude.rs +123 -0
- package/crates/team-agent/src/provider/session/context_fork/outcome.rs +4 -0
- package/crates/team-agent/src/provider/session/context_fork.rs +150 -18
- package/crates/team-agent/src/provider/session_scan/claude.rs +523 -0
- package/crates/team-agent/src/provider/session_scan/common.rs +44 -8
- package/crates/team-agent/src/provider/session_scan/pi.rs +34 -1
- package/crates/team-agent/src/provider/session_scan.rs +16 -6
- package/crates/team-agent/src/provider/tests/adapter.rs +104 -17
- package/crates/team-agent/src/provider/tests/classify.rs +0 -53
- package/crates/team-agent/src/provider/tests/command_helpers.rs +12 -3
- package/crates/team-agent/src/provider/tests/idle.rs +37 -0
- package/crates/team-agent/src/provider/wire.rs +22 -34
- package/crates/team-agent/src/state/abnormal_watch/tests/mod.rs +1 -1
- package/crates/team-agent/src/state/persist.rs +6 -6
- package/crates/team-agent/src/state/projection.rs +1 -1
- package/crates/team-agent/src/state/repository/tests.rs +2 -2
- package/crates/team-agent/src/test_support/models_timeout_fixture.rs +144 -0
- package/crates/team-agent/src/tmux_backend/tests.rs +0 -151
- package/crates/team-agent/src/tmux_backend.rs +5 -40
- package/package.json +4 -4
- package/skills/team-agent/SKILL.md +5 -7
- package/skills/team-agent/command-coverage.json +1 -1
- package/skills/team-agent/docs/reference/team-agent-operator.md +3 -3
- package/skills/team-agent/references/team-agent-operator.md +3 -3
|
@@ -0,0 +1,316 @@
|
|
|
1
|
+
//! Durable leader reminders; the existing coordinator is the only timer process.
|
|
2
|
+
use std::path::Path;
|
|
3
|
+
|
|
4
|
+
use chrono::{Duration, SecondsFormat, Utc};
|
|
5
|
+
use rusqlite::{params, OptionalExtension};
|
|
6
|
+
use serde::{Deserialize, Serialize};
|
|
7
|
+
use serde_json::{json, Value};
|
|
8
|
+
|
|
9
|
+
use super::MessagingError;
|
|
10
|
+
use crate::{event_log::EventLog, message_store::MessageStore};
|
|
11
|
+
|
|
12
|
+
#[derive(Serialize, Deserialize)]
|
|
13
|
+
struct Reminder {
|
|
14
|
+
text: String,
|
|
15
|
+
trigger: String,
|
|
16
|
+
interval_ms: Option<i64>,
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
pub(crate) fn parse_duration(raw: &str) -> Result<Duration, MessagingError> {
|
|
20
|
+
let split = raw.find(|c: char| !c.is_ascii_digit()).unwrap_or(raw.len());
|
|
21
|
+
let (amount, unit) = raw.split_at(split);
|
|
22
|
+
let multiplier = match unit {
|
|
23
|
+
"ms" => 1,
|
|
24
|
+
"s" => 1_000,
|
|
25
|
+
"m" => 60_000,
|
|
26
|
+
"h" => 3_600_000,
|
|
27
|
+
"d" => 86_400_000,
|
|
28
|
+
_ => 0,
|
|
29
|
+
};
|
|
30
|
+
amount.parse::<i64>().ok()
|
|
31
|
+
.and_then(|amount| amount.checked_mul(multiplier))
|
|
32
|
+
.filter(|ms| *ms > 0)
|
|
33
|
+
.and_then(Duration::try_milliseconds)
|
|
34
|
+
.filter(|duration| Utc::now().checked_add_signed(*duration).is_some())
|
|
35
|
+
.ok_or_else(|| MessagingError::Validation("duration must be a positive integer followed by ms, s, m, h or d, within the supported date range".into()))
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
pub(crate) fn parse_id(id: &str) -> Option<i64> {
|
|
39
|
+
let hex = id.strip_prefix("sched_")?;
|
|
40
|
+
if hex.is_empty() || !hex.bytes().all(|c| c.is_ascii_hexdigit()) {
|
|
41
|
+
return None;
|
|
42
|
+
}
|
|
43
|
+
i64::from_str_radix(hex, 16).ok().filter(|id| *id > 0)
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
fn view(id: i64, reminder: &Reminder) -> Value {
|
|
47
|
+
json!({"id": format!("sched_{id:x}"), "trigger": reminder.trigger,
|
|
48
|
+
"text": reminder.text, "status": "active"})
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
pub(crate) fn add(
|
|
52
|
+
workspace: &Path,
|
|
53
|
+
owner: &str,
|
|
54
|
+
text: &str,
|
|
55
|
+
duration: &str,
|
|
56
|
+
recurring: bool,
|
|
57
|
+
) -> Result<Value, MessagingError> {
|
|
58
|
+
let interval = parse_duration(duration)?;
|
|
59
|
+
let now = Utc::now();
|
|
60
|
+
let due = now.checked_add_signed(interval).ok_or_else(|| {
|
|
61
|
+
MessagingError::Validation("duration exceeds supported date range".into())
|
|
62
|
+
})?;
|
|
63
|
+
let reminder = Reminder {
|
|
64
|
+
text: text.to_owned(),
|
|
65
|
+
trigger: format!("{} {duration}", if recurring { "every" } else { "in" }),
|
|
66
|
+
interval_ms: recurring.then_some(interval.num_milliseconds()),
|
|
67
|
+
};
|
|
68
|
+
let store = MessageStore::open(workspace)?;
|
|
69
|
+
let conn = crate::db::schema::open_db(store.db_path())?;
|
|
70
|
+
conn.execute(
|
|
71
|
+
"insert into scheduled_events (due_at, target, kind, payload_json, status, created_at, owner_team_id) values (?1, 'leader', 'reminder', ?2, 'pending', ?3, ?4)",
|
|
72
|
+
params![due.to_rfc3339_opts(SecondsFormat::Nanos, false), serde_json::to_string(&reminder)?, now.to_rfc3339(), owner],
|
|
73
|
+
)?;
|
|
74
|
+
let mut value = view(conn.last_insert_rowid(), &reminder);
|
|
75
|
+
value["ok"] = json!(true);
|
|
76
|
+
Ok(value)
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
pub(crate) fn list(workspace: &Path, owner: &str) -> Result<Vec<Value>, MessagingError> {
|
|
80
|
+
let store = MessageStore::open(workspace)?;
|
|
81
|
+
let conn = crate::db::schema::open_db(store.db_path())?;
|
|
82
|
+
let mut statement = conn.prepare("select id, payload_json from scheduled_events where kind='reminder' and owner_team_id=?1 and status='pending' order by id")?;
|
|
83
|
+
let rows = statement.query_map([owner], |row| {
|
|
84
|
+
Ok((row.get::<_, i64>(0)?, row.get::<_, String>(1)?))
|
|
85
|
+
})?;
|
|
86
|
+
rows.map(|row| {
|
|
87
|
+
let (id, payload) = row?;
|
|
88
|
+
Ok(view(id, &serde_json::from_str(&payload)?))
|
|
89
|
+
})
|
|
90
|
+
.collect()
|
|
91
|
+
}
|
|
92
|
+
|
|
93
|
+
pub(crate) fn cancel(workspace: &Path, owner: &str, id: i64) -> Result<bool, MessagingError> {
|
|
94
|
+
let store = MessageStore::open(workspace)?;
|
|
95
|
+
let conn = crate::db::schema::open_db(store.db_path())?;
|
|
96
|
+
// An occurrence already fired is not recalled.
|
|
97
|
+
Ok(conn.execute("update scheduled_events set status='cancelled' where id=?1 and kind='reminder' and owner_team_id=?2 and status='pending'", params![id, owner])? == 1)
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
pub(super) fn fire(
|
|
101
|
+
workspace: &Path,
|
|
102
|
+
id: i64,
|
|
103
|
+
_event_log: &EventLog,
|
|
104
|
+
) -> Result<Value, MessagingError> {
|
|
105
|
+
let store = MessageStore::open(workspace)?;
|
|
106
|
+
let mut conn = crate::db::schema::open_db(store.db_path())?;
|
|
107
|
+
// Serialize occurrences/cancellation, never wait for a delivery receipt.
|
|
108
|
+
let tx = conn.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?;
|
|
109
|
+
let row = tx.query_row(
|
|
110
|
+
"select due_at, payload_json, owner_team_id from scheduled_events where id=?1 and kind='reminder' and status='pending'",
|
|
111
|
+
[id], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?, row.get::<_, String>(2)?)),
|
|
112
|
+
).optional()?;
|
|
113
|
+
let Some((due_at, payload, owner)) = row else {
|
|
114
|
+
return Ok(json!({"ok": true, "cancelled": true}));
|
|
115
|
+
};
|
|
116
|
+
let reminder: Reminder = serde_json::from_str(&payload)?;
|
|
117
|
+
let directory = crate::direct_delivery::directory(workspace, Some(&owner))
|
|
118
|
+
.map_err(MessagingError::Routing)?;
|
|
119
|
+
// The inbox is durable independently of physical delivery. A stable id also
|
|
120
|
+
// makes replay after an append/before timer commit safe without ledger rows.
|
|
121
|
+
let message_id = format!("reminder_{id}_{due_at}");
|
|
122
|
+
let inbox = crate::inbox_store::read(workspace, "leader", usize::MAX, Some(&owner))
|
|
123
|
+
.map_err(std::io::Error::other)?;
|
|
124
|
+
if !inbox["messages"].as_array().into_iter().flatten()
|
|
125
|
+
.any(|record| record["message_id"] == message_id)
|
|
126
|
+
{
|
|
127
|
+
let mut record = crate::inbox_store::record("scheduler", "leader", &reminder.text, Some(&owner), "reminder");
|
|
128
|
+
record["message_id"] = json!(message_id);
|
|
129
|
+
crate::inbox_store::append(workspace, "leader", &record)
|
|
130
|
+
.map_err(std::io::Error::other)?;
|
|
131
|
+
}
|
|
132
|
+
let next_due = reminder
|
|
133
|
+
.interval_ms
|
|
134
|
+
.and_then(Duration::try_milliseconds)
|
|
135
|
+
.filter(|duration| *duration > Duration::zero())
|
|
136
|
+
.and_then(|interval| Utc::now().checked_add_signed(interval))
|
|
137
|
+
.map(|due| due.to_rfc3339_opts(SecondsFormat::Nanos, false));
|
|
138
|
+
let mut result = json!({"ok": true, "message_id": message_id, "next_due_at": next_due, "delivery": "inbox"});
|
|
139
|
+
// Compare due_at as well as status: concurrent ticks or cancellation cannot
|
|
140
|
+
// advance the same occurrence twice, or resurrect a cancelled reminder.
|
|
141
|
+
tx.execute(
|
|
142
|
+
"update scheduled_events set status=?1, due_at=coalesce(?2, due_at), fired_at=?3, result_json=?4 where id=?5 and status='pending' and due_at=?6",
|
|
143
|
+
params![if next_due.is_some() { "pending" } else { "done" }, next_due, Utc::now().to_rfc3339(), result.to_string(), id, due_at],
|
|
144
|
+
)?;
|
|
145
|
+
tx.commit()?;
|
|
146
|
+
// Once consumed, physical delivery is best effort: a crash or detached pane
|
|
147
|
+
// still leaves the reminder in the inbox, never awaiting a legacy receipt.
|
|
148
|
+
match directory.send("leader", &format!("Team Agent reminder:\n\n{}", reminder.text)) {
|
|
149
|
+
Ok(_) => result["delivery"] = json!("physical"),
|
|
150
|
+
Err(error) => result["delivery_error"] = json!(error),
|
|
151
|
+
}
|
|
152
|
+
conn.execute(
|
|
153
|
+
"update scheduled_events set result_json=?1 where id=?2 and json_extract(result_json, '$.message_id')=?3",
|
|
154
|
+
params![result.to_string(), id, message_id],
|
|
155
|
+
)?;
|
|
156
|
+
Ok(result)
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
#[cfg(test)]
|
|
160
|
+
mod tests {
|
|
161
|
+
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
|
|
162
|
+
use super::*;
|
|
163
|
+
|
|
164
|
+
struct TestWorkspace(std::path::PathBuf);
|
|
165
|
+
impl TestWorkspace {
|
|
166
|
+
fn path(&self) -> &Path {
|
|
167
|
+
&self.0
|
|
168
|
+
}
|
|
169
|
+
}
|
|
170
|
+
impl Drop for TestWorkspace {
|
|
171
|
+
fn drop(&mut self) {
|
|
172
|
+
let _ = std::fs::remove_dir_all(&self.0);
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
fn workspace() -> TestWorkspace {
|
|
176
|
+
static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
|
|
177
|
+
let dir = TestWorkspace(std::env::temp_dir().join(format!(
|
|
178
|
+
"ta-reminders-{}-{}",
|
|
179
|
+
std::process::id(),
|
|
180
|
+
NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
|
|
181
|
+
)));
|
|
182
|
+
let state = json!({"active_team_key": "alpha", "team_key": "alpha", "teams": {
|
|
183
|
+
"alpha": {"team_key": "alpha", "agents": {}},
|
|
184
|
+
"beta": {"team_key": "beta", "agents": {}}
|
|
185
|
+
}});
|
|
186
|
+
let path = crate::state::persist::runtime_state_path(dir.path());
|
|
187
|
+
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
|
|
188
|
+
std::fs::write(path, state.to_string()).unwrap();
|
|
189
|
+
dir
|
|
190
|
+
}
|
|
191
|
+
|
|
192
|
+
#[test]
|
|
193
|
+
fn durations_and_ids_are_strict_and_bounded() {
|
|
194
|
+
for (raw, milliseconds) in [
|
|
195
|
+
("1ms", 1),
|
|
196
|
+
("2s", 2000),
|
|
197
|
+
("3m", 180000),
|
|
198
|
+
("1h", 3600000),
|
|
199
|
+
("1d", 86400000),
|
|
200
|
+
] {
|
|
201
|
+
assert_eq!(
|
|
202
|
+
parse_duration(raw).unwrap().num_milliseconds(),
|
|
203
|
+
milliseconds
|
|
204
|
+
);
|
|
205
|
+
}
|
|
206
|
+
for raw in [
|
|
207
|
+
"",
|
|
208
|
+
"0s",
|
|
209
|
+
"-1s",
|
|
210
|
+
"1",
|
|
211
|
+
"1.5s",
|
|
212
|
+
"NaNs",
|
|
213
|
+
"1w",
|
|
214
|
+
"1s2m",
|
|
215
|
+
"999999999999999999999d",
|
|
216
|
+
"9223372036854775807ms",
|
|
217
|
+
] {
|
|
218
|
+
assert!(parse_duration(raw).is_err(), "{raw}");
|
|
219
|
+
}
|
|
220
|
+
assert_eq!(parse_id("sched_1a"), Some(26));
|
|
221
|
+
for raw in [
|
|
222
|
+
"1",
|
|
223
|
+
"sched_",
|
|
224
|
+
"sched_-1",
|
|
225
|
+
"sched_+1",
|
|
226
|
+
"sched_0",
|
|
227
|
+
"sched_ffffffffffffffff",
|
|
228
|
+
] {
|
|
229
|
+
assert_eq!(parse_id(raw), None, "{raw}");
|
|
230
|
+
}
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
#[test]
|
|
234
|
+
fn list_and_cancel_are_persistent_and_team_scoped() {
|
|
235
|
+
let dir = workspace();
|
|
236
|
+
let added = add(dir.path(), "alpha", "check status", "1h", true).unwrap();
|
|
237
|
+
assert_eq!(added["trigger"], "every 1h");
|
|
238
|
+
assert_eq!(added["status"], "active");
|
|
239
|
+
let id = parse_id(added["id"].as_str().unwrap()).unwrap();
|
|
240
|
+
assert_eq!(list(dir.path(), "alpha").unwrap().len(), 1);
|
|
241
|
+
assert!(list(dir.path(), "beta").unwrap().is_empty());
|
|
242
|
+
assert!(!cancel(dir.path(), "beta", id).unwrap());
|
|
243
|
+
assert!(cancel(dir.path(), "alpha", id).unwrap());
|
|
244
|
+
assert!(!cancel(dir.path(), "alpha", id).unwrap());
|
|
245
|
+
assert!(list(dir.path(), "alpha").unwrap().is_empty());
|
|
246
|
+
let log = EventLog::new(dir.path());
|
|
247
|
+
assert_eq!(fire(dir.path(), id, &log).unwrap()["cancelled"], true);
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
#[test]
|
|
251
|
+
fn one_shot_stores_once_and_uses_owner_not_active_team() {
|
|
252
|
+
let dir = workspace();
|
|
253
|
+
let added = add(dir.path(), "beta", "beta reminder", "1ms", false).unwrap();
|
|
254
|
+
let id = parse_id(added["id"].as_str().unwrap()).unwrap();
|
|
255
|
+
let log = EventLog::new(dir.path());
|
|
256
|
+
let result = fire(dir.path(), id, &log).unwrap();
|
|
257
|
+
assert_eq!(result["delivery"], "inbox");
|
|
258
|
+
assert!(result["delivery_error"].is_string());
|
|
259
|
+
fire(dir.path(), id, &log).unwrap();
|
|
260
|
+
let inbox = crate::inbox_store::read(dir.path(), "leader", usize::MAX, None).unwrap();
|
|
261
|
+
let records = inbox["messages"].as_array().unwrap();
|
|
262
|
+
assert_eq!(records.len(), 1);
|
|
263
|
+
assert_eq!(records[0]["team"], "beta");
|
|
264
|
+
assert_eq!(records[0]["recipient"], "leader");
|
|
265
|
+
assert_eq!(records[0]["kind"], "reminder");
|
|
266
|
+
assert_eq!(records[0]["content"], "beta reminder");
|
|
267
|
+
let store = MessageStore::open(dir.path()).unwrap();
|
|
268
|
+
let conn = crate::db::schema::open_db(store.db_path()).unwrap();
|
|
269
|
+
assert_eq!(conn.query_row("select count(*) from messages", [], |row| row.get::<_, i64>(0)).unwrap(), 0);
|
|
270
|
+
assert!(list(dir.path(), "beta").unwrap().is_empty());
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
#[test]
|
|
274
|
+
fn recurring_occurrences_are_unique_and_crash_replay_is_idempotent() {
|
|
275
|
+
let dir = workspace();
|
|
276
|
+
let added = add(dir.path(), "alpha", "periodic", "1s", true).unwrap();
|
|
277
|
+
let id = parse_id(added["id"].as_str().unwrap()).unwrap();
|
|
278
|
+
let log = EventLog::new(dir.path());
|
|
279
|
+
let store = MessageStore::open(dir.path()).unwrap();
|
|
280
|
+
let conn = crate::db::schema::open_db(store.db_path()).unwrap();
|
|
281
|
+
let original_due: String = conn.query_row(
|
|
282
|
+
"select due_at from scheduled_events where id=?1", [id], |row| row.get(0),
|
|
283
|
+
).unwrap();
|
|
284
|
+
let count = || crate::inbox_store::read(dir.path(), "leader", usize::MAX, None).unwrap()["messages"].as_array().unwrap().len();
|
|
285
|
+
fire(dir.path(), id, &log).unwrap();
|
|
286
|
+
assert_eq!(list(dir.path(), "alpha").unwrap().len(), 1);
|
|
287
|
+
// Simulate the crash window after inbox append, before timer commit.
|
|
288
|
+
conn.execute("update scheduled_events set due_at=?1 where id=?2", params![original_due, id]).unwrap();
|
|
289
|
+
fire(dir.path(), id, &log).unwrap();
|
|
290
|
+
assert_eq!(count(), 1);
|
|
291
|
+
fire(dir.path(), id, &log).unwrap();
|
|
292
|
+
assert_eq!(count(), 2);
|
|
293
|
+
assert!(cancel(dir.path(), "alpha", id).unwrap());
|
|
294
|
+
fire(dir.path(), id, &log).unwrap();
|
|
295
|
+
assert_eq!(count(), 2);
|
|
296
|
+
assert_eq!(conn.query_row("select count(*) from messages", [], |row| row.get::<_, i64>(0)).unwrap(), 0);
|
|
297
|
+
}
|
|
298
|
+
|
|
299
|
+
#[test]
|
|
300
|
+
fn concurrent_fires_consume_one_occurrence_and_one_inbox_record() {
|
|
301
|
+
let dir = workspace();
|
|
302
|
+
let added = add(dir.path(), "alpha", "once", "1ms", false).unwrap();
|
|
303
|
+
let id = parse_id(added["id"].as_str().unwrap()).unwrap();
|
|
304
|
+
let barrier = std::sync::Barrier::new(2);
|
|
305
|
+
std::thread::scope(|scope| {
|
|
306
|
+
let handles: Vec<_> = (0..2).map(|_| scope.spawn(|| {
|
|
307
|
+
barrier.wait();
|
|
308
|
+
fire(dir.path(), id, &EventLog::new(dir.path())).unwrap()
|
|
309
|
+
})).collect();
|
|
310
|
+
let results: Vec<_> = handles.into_iter().map(|handle| handle.join().unwrap()).collect();
|
|
311
|
+
assert_eq!(results.iter().filter(|result| result["cancelled"] == true).count(), 1);
|
|
312
|
+
});
|
|
313
|
+
let inbox = crate::inbox_store::read(dir.path(), "leader", usize::MAX, None).unwrap();
|
|
314
|
+
assert_eq!(inbox["messages"].as_array().unwrap().len(), 1);
|
|
315
|
+
}
|
|
316
|
+
}
|
|
@@ -53,6 +53,7 @@ pub fn fire_due_scheduled_events(
|
|
|
53
53
|
let fire_one = || -> Result<serde_json::Value, MessagingError> {
|
|
54
54
|
let scheduled_kind = parse_scheduled_kind(&kind)?;
|
|
55
55
|
let result = match scheduled_kind {
|
|
56
|
+
ScheduledKind::Reminder => super::reminders::fire(workspace, id, event_log)?,
|
|
56
57
|
ScheduledKind::Send => {
|
|
57
58
|
let payload: serde_json::Value = serde_json::from_str(&payload_json)?;
|
|
58
59
|
let outcome = deliver_stored_message(
|
|
@@ -132,6 +133,11 @@ pub fn fire_due_scheduled_events(
|
|
|
132
133
|
|
|
133
134
|
let (status, result_json) = match fire_one() {
|
|
134
135
|
Ok(result) => {
|
|
136
|
+
// Reminder dispatch owns recurrence advancement and cancellation.
|
|
137
|
+
if kind == "reminder" {
|
|
138
|
+
fired.push(id);
|
|
139
|
+
continue;
|
|
140
|
+
}
|
|
135
141
|
let ok = result
|
|
136
142
|
.get("ok")
|
|
137
143
|
.and_then(serde_json::Value::as_bool)
|
|
@@ -158,7 +164,7 @@ pub fn fire_due_scheduled_events(
|
|
|
158
164
|
// The row-status write stays `?`: a DB write failure is a real store fault, not a
|
|
159
165
|
// per-event poison, and should surface (consistent with the rest of the fn).
|
|
160
166
|
conn.execute(
|
|
161
|
-
"update scheduled_events set status = ?2, fired_at = ?3, result_json = ?4 where id = ?1",
|
|
167
|
+
"update scheduled_events set status = ?2, fired_at = ?3, result_json = ?4 where id = ?1 and status = 'pending'",
|
|
162
168
|
params![id, status, chrono::Utc::now().to_rfc3339(), result_json],
|
|
163
169
|
)?;
|
|
164
170
|
fired.push(id);
|
|
@@ -30,7 +30,7 @@ use crate::transport::{
|
|
|
30
30
|
|
|
31
31
|
#[test]
|
|
32
32
|
#[cfg(unix)]
|
|
33
|
-
fn
|
|
33
|
+
fn issue372_missing_mcp_receipt_delivers_immediately_without_duplicate_input() {
|
|
34
34
|
let mut case = WorkerCase::new("mcp-handshake", "copilot");
|
|
35
35
|
let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
|
|
36
36
|
let config = case.workspace.join(".team/runtime/mcp/w1.json");
|
|
@@ -44,112 +44,218 @@ fn eager_mcp_waits_without_spending_input_attempts_then_delivers_the_same_messag
|
|
|
44
44
|
case.state["team_key"] = serde_json::json!("dup-team");
|
|
45
45
|
case.state["agents"]["w1"]["mcp_config"] = serde_json::json!(config);
|
|
46
46
|
case.state["agents"]["w1"]["pane_pid"] = serde_json::json!(carrier);
|
|
47
|
-
case.state["agents"]["w1"]["spawned_at"] =
|
|
47
|
+
case.state["agents"]["w1"]["spawned_at"] =
|
|
48
|
+
serde_json::json!((chrono::Utc::now() - chrono::Duration::seconds(10)).to_rfc3339());
|
|
48
49
|
case.state["teams"] = serde_json::json!({"dup-team": case.state.clone()});
|
|
49
50
|
crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
|
|
50
|
-
let transport = RecordingTransport {
|
|
51
|
-
|
|
51
|
+
let transport = RecordingTransport {
|
|
52
|
+
carrier: Some(carrier),
|
|
53
|
+
..RecordingTransport::new("")
|
|
54
|
+
};
|
|
55
|
+
let message_id = case
|
|
56
|
+
.store
|
|
57
|
+
.create_message(
|
|
58
|
+
None,
|
|
59
|
+
"leader",
|
|
60
|
+
"w1",
|
|
61
|
+
"handshake canary",
|
|
62
|
+
None,
|
|
63
|
+
false,
|
|
64
|
+
Some("dup-team"),
|
|
65
|
+
)
|
|
66
|
+
.unwrap();
|
|
52
67
|
for _ in 0..3 {
|
|
53
|
-
let outcome = deliver_pending_message(
|
|
54
|
-
&
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
68
|
+
let outcome = deliver_pending_message(
|
|
69
|
+
&case.workspace,
|
|
70
|
+
&case.store,
|
|
71
|
+
&transport,
|
|
72
|
+
&message_id,
|
|
73
|
+
&case.event_log,
|
|
74
|
+
&case.state,
|
|
75
|
+
)
|
|
76
|
+
.unwrap();
|
|
77
|
+
assert_eq!(
|
|
78
|
+
transport.inject_count(),
|
|
79
|
+
1,
|
|
80
|
+
"live pane must receive input immediately: {outcome:?}"
|
|
81
|
+
);
|
|
58
82
|
}
|
|
59
83
|
let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
|
|
60
|
-
let attempts: i64 = connection
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
84
|
+
let attempts: i64 = connection
|
|
85
|
+
.query_row(
|
|
86
|
+
"select delivery_attempts from messages where message_id=?1",
|
|
87
|
+
[&message_id],
|
|
88
|
+
|row| row.get(0),
|
|
89
|
+
)
|
|
90
|
+
.unwrap();
|
|
91
|
+
assert_eq!(
|
|
92
|
+
attempts, 1,
|
|
93
|
+
"readiness must not park or refund the delivery"
|
|
94
|
+
);
|
|
95
|
+
assert!(case.events().contains("delivery.mcp_handshake_warning"));
|
|
96
|
+
assert!(!case.events().contains("delivery.deferred_mcp_handshake"));
|
|
97
|
+
crate::mcp_server::readiness::publish(&case.workspace, "dup-team", "w1", chrono::Utc::now())
|
|
98
|
+
.unwrap();
|
|
99
|
+
let outcome = deliver_pending_message(
|
|
100
|
+
&case.workspace,
|
|
101
|
+
&case.store,
|
|
102
|
+
&transport,
|
|
103
|
+
&message_id,
|
|
104
|
+
&case.event_log,
|
|
105
|
+
&case.state,
|
|
106
|
+
)
|
|
107
|
+
.unwrap();
|
|
65
108
|
assert_eq!(outcome.message_id.as_deref(), Some(message_id.as_str()));
|
|
66
|
-
assert_eq!(
|
|
109
|
+
assert_eq!(
|
|
110
|
+
transport.inject_count(),
|
|
111
|
+
1,
|
|
112
|
+
"late receipt must not replay an already injected row"
|
|
113
|
+
);
|
|
67
114
|
}
|
|
68
115
|
|
|
69
116
|
#[test]
|
|
70
117
|
#[cfg(unix)]
|
|
71
|
-
fn
|
|
72
|
-
let mut case = WorkerCase::new("mcp-
|
|
118
|
+
fn issue372_missing_mcp_config_is_diagnostic_not_a_delivery_gate() {
|
|
119
|
+
let mut case = WorkerCase::new("missing-mcp-config", "copilot");
|
|
73
120
|
let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
|
|
74
|
-
let config = case.workspace.join(".team/runtime/mcp/w1.json");
|
|
75
|
-
std::fs::create_dir_all(config.parent().unwrap()).unwrap();
|
|
76
|
-
std::fs::write(&config, serde_json::to_vec(&serde_json::json!({
|
|
77
|
-
"mcpServers": {"team_orchestrator": {
|
|
78
|
-
"command": std::env::current_exe().unwrap().canonicalize().unwrap(),
|
|
79
|
-
"env": {"TEAM_AGENT_WORKSPACE": case.workspace, "TEAM_AGENT_ID": "w1", "TEAM_AGENT_OWNER_TEAM_ID": "dup-team"}
|
|
80
|
-
}}
|
|
81
|
-
})).unwrap()).unwrap();
|
|
82
|
-
let long_ago = (chrono::Utc::now() - chrono::Duration::seconds(400)).to_rfc3339();
|
|
83
121
|
case.state["team_key"] = serde_json::json!("dup-team");
|
|
84
|
-
case.state["agents"]["w1"]["mcp_config"] = serde_json::json!(config);
|
|
85
122
|
case.state["agents"]["w1"]["pane_pid"] = serde_json::json!(carrier);
|
|
86
|
-
case.state["agents"]["w1"]["spawned_at"] = serde_json::json!(
|
|
123
|
+
case.state["agents"]["w1"]["spawned_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
|
|
87
124
|
case.state["teams"] = serde_json::json!({"dup-team": case.state.clone()});
|
|
88
125
|
crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
|
|
89
|
-
let transport = RecordingTransport {
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
.collect();
|
|
93
|
-
let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
|
|
94
|
-
connection.execute("update messages set created_at = ?1", [&long_ago]).unwrap();
|
|
95
|
-
for id in &ids {
|
|
96
|
-
let outcome = deliver_pending_message(&case.workspace, &case.store, &transport,
|
|
97
|
-
id, &case.event_log, &case.state).unwrap();
|
|
98
|
-
assert_eq!(outcome.message_status.0, "queued_until_start", "{outcome:?}");
|
|
99
|
-
assert!(outcome.verification.as_deref().unwrap().starts_with("mcp_handshake_timeout:mcp_handshake_"));
|
|
100
|
-
}
|
|
101
|
-
assert_eq!(transport.inject_count(), 0, "a parked wait never reaches input");
|
|
102
|
-
let row = |id: &str| -> (String, Option<String>, i64) {
|
|
103
|
-
connection.query_row(
|
|
104
|
-
"select status, error, delivery_attempts from messages where message_id = ?1",
|
|
105
|
-
[id], |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
|
|
106
|
-
).unwrap()
|
|
126
|
+
let transport = RecordingTransport {
|
|
127
|
+
carrier: Some(carrier),
|
|
128
|
+
..RecordingTransport::new("")
|
|
107
129
|
};
|
|
108
|
-
|
|
109
|
-
|
|
130
|
+
let message_id = case
|
|
131
|
+
.store
|
|
132
|
+
.create_message(
|
|
133
|
+
None,
|
|
134
|
+
"leader",
|
|
135
|
+
"w1",
|
|
136
|
+
"missing config canary",
|
|
137
|
+
None,
|
|
138
|
+
false,
|
|
139
|
+
Some("dup-team"),
|
|
140
|
+
)
|
|
141
|
+
.unwrap();
|
|
142
|
+
for _ in 0..3 {
|
|
143
|
+
let outcome = deliver_pending_message(
|
|
144
|
+
&case.workspace,
|
|
145
|
+
&case.store,
|
|
146
|
+
&transport,
|
|
147
|
+
&message_id,
|
|
148
|
+
&case.event_log,
|
|
149
|
+
&case.state,
|
|
150
|
+
)
|
|
151
|
+
.unwrap();
|
|
152
|
+
assert_eq!(
|
|
153
|
+
transport.inject_count(),
|
|
154
|
+
1,
|
|
155
|
+
"missing metadata cannot block a live pane: {outcome:?}"
|
|
156
|
+
);
|
|
110
157
|
}
|
|
111
|
-
let
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
assert_eq!(
|
|
158
|
+
let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
|
|
159
|
+
let attempts: i64 = connection
|
|
160
|
+
.query_row(
|
|
161
|
+
"select delivery_attempts from messages where message_id=?1",
|
|
162
|
+
[&message_id],
|
|
163
|
+
|row| row.get(0),
|
|
164
|
+
)
|
|
165
|
+
.unwrap();
|
|
166
|
+
assert_eq!(attempts, 1, "metadata must not suppress or duplicate input");
|
|
167
|
+
assert!(case.events().contains("mcp_handshake_config_missing"));
|
|
168
|
+
}
|
|
120
169
|
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
170
|
+
#[test]
|
|
171
|
+
#[cfg(unix)]
|
|
172
|
+
fn issue372_bad_receipts_never_park_live_pane_delivery() {
|
|
173
|
+
for fault in ["dead", "ancestry", "malformed"] {
|
|
174
|
+
let mut case = WorkerCase::new(fault, "copilot");
|
|
175
|
+
let pane = crate::mcp_server::readiness::test_ready_worker(
|
|
176
|
+
&case.workspace,
|
|
177
|
+
&mut case.state,
|
|
178
|
+
"dup-team",
|
|
179
|
+
"w1",
|
|
180
|
+
"%w1",
|
|
181
|
+
);
|
|
182
|
+
crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
|
|
183
|
+
let receipt = std::fs::read_dir(case.workspace.join(".team/runtime/mcp-handshakes"))
|
|
184
|
+
.unwrap()
|
|
185
|
+
.map(|entry| entry.unwrap().path())
|
|
186
|
+
.find(|path| path.extension().is_some_and(|ext| ext == "json"))
|
|
187
|
+
.unwrap();
|
|
188
|
+
let mut value: serde_json::Value =
|
|
189
|
+
serde_json::from_slice(&std::fs::read(&receipt).unwrap()).unwrap();
|
|
190
|
+
match fault {
|
|
191
|
+
"dead" => value["server"]["identity"]["pid"] = serde_json::json!(u32::MAX),
|
|
192
|
+
"ancestry" => value["ancestors"] = serde_json::json!([]),
|
|
193
|
+
_ => value = serde_json::json!("invalid receipt"),
|
|
194
|
+
}
|
|
195
|
+
std::fs::write(receipt, serde_json::to_vec(&value).unwrap()).unwrap();
|
|
196
|
+
let transport = RecordingTransport {
|
|
197
|
+
carrier: pane.pane_pid,
|
|
198
|
+
..RecordingTransport::new("")
|
|
199
|
+
};
|
|
200
|
+
let message_id = case
|
|
201
|
+
.store
|
|
202
|
+
.create_message(
|
|
203
|
+
None,
|
|
204
|
+
"leader",
|
|
205
|
+
"w1",
|
|
206
|
+
"bad receipt canary",
|
|
207
|
+
None,
|
|
208
|
+
false,
|
|
209
|
+
Some("dup-team"),
|
|
210
|
+
)
|
|
211
|
+
.unwrap();
|
|
212
|
+
for _ in 0..2 {
|
|
213
|
+
deliver_pending_message(
|
|
214
|
+
&case.workspace,
|
|
215
|
+
&case.store,
|
|
216
|
+
&transport,
|
|
217
|
+
&message_id,
|
|
218
|
+
&case.event_log,
|
|
219
|
+
&case.state,
|
|
220
|
+
)
|
|
221
|
+
.unwrap();
|
|
222
|
+
assert_eq!(
|
|
223
|
+
transport.inject_count(),
|
|
224
|
+
1,
|
|
225
|
+
"{fault} must not block or duplicate input"
|
|
226
|
+
);
|
|
227
|
+
}
|
|
228
|
+
assert!(
|
|
229
|
+
case.events().contains("delivery.mcp_handshake_warning"),
|
|
230
|
+
"{fault}"
|
|
231
|
+
);
|
|
232
|
+
assert!(
|
|
233
|
+
!case.events().contains("delivery.deferred_mcp_handshake"),
|
|
234
|
+
"{fault}"
|
|
235
|
+
);
|
|
236
|
+
let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
|
|
237
|
+
let (status, attempts): (String, i64) = connection
|
|
238
|
+
.query_row(
|
|
239
|
+
"SELECT status,delivery_attempts FROM messages WHERE message_id=?1",
|
|
240
|
+
[&message_id],
|
|
241
|
+
|row| Ok((row.get(0)?, row.get(1)?)),
|
|
242
|
+
)
|
|
243
|
+
.unwrap();
|
|
244
|
+
assert_ne!(status, "target_resolved", "{fault}");
|
|
245
|
+
assert_eq!(attempts, 1, "{fault}");
|
|
124
246
|
}
|
|
125
|
-
let outcome = deliver_pending_message(&case.workspace, &case.store, &transport,
|
|
126
|
-
&ids[0], &case.event_log, &case.state).unwrap();
|
|
127
|
-
assert_eq!(outcome.message_id.as_deref(), Some(ids[0].as_str()));
|
|
128
|
-
assert_eq!(transport.inject_count(), 1, "the same parked row is delivered after the receipt");
|
|
129
247
|
}
|
|
130
248
|
|
|
131
249
|
#[test]
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
let
|
|
135
|
-
let
|
|
136
|
-
case.
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
|
|
141
|
-
let transport = RecordingTransport { carrier: Some(carrier), ..RecordingTransport::new("") };
|
|
142
|
-
let message_id = case.store.create_message(None, "leader", "w1", "missing config canary", None, false, Some("dup-team")).unwrap();
|
|
143
|
-
for _ in 0..3 {
|
|
144
|
-
let outcome = deliver_pending_message(&case.workspace, &case.store, &transport,
|
|
145
|
-
&message_id, &case.event_log, &case.state).unwrap();
|
|
146
|
-
assert!(!outcome.ok);
|
|
147
|
-
assert!(outcome.verification.as_deref().unwrap().starts_with("mcp_handshake_"));
|
|
148
|
-
assert_eq!(transport.inject_count(), 0, "missing metadata must never reach input");
|
|
250
|
+
fn issue372_existing_timeout_rows_resume_without_republication() {
|
|
251
|
+
let case = WorkerCase::new("legacy-timeout", "fake");
|
|
252
|
+
let transport = RecordingTransport::new("");
|
|
253
|
+
let message_id = case.seed_leader_to_worker("legacy parked canary");
|
|
254
|
+
case.store.mark(&message_id, "queued_until_start", Some(crate::message_store::MCP_HANDSHAKE_TIMEOUT)).unwrap();
|
|
255
|
+
for _ in 0..2 {
|
|
256
|
+
crate::messaging::deliver_pending_messages(&case.workspace, &case.state, &transport, &case.event_log).unwrap();
|
|
257
|
+
assert_eq!(transport.inject_count(), 1);
|
|
149
258
|
}
|
|
150
|
-
let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
|
|
151
|
-
let attempts: i64 = connection.query_row("select delivery_attempts from messages where message_id=?1", [&message_id], |row| row.get(0)).unwrap();
|
|
152
|
-
assert_eq!(attempts, 0, "metadata wait is not an input attempt");
|
|
153
259
|
}
|
|
154
260
|
|
|
155
261
|
#[test]
|
|
@@ -294,7 +400,7 @@ fn pane_token_refuses_second_inject_for_copilot() {
|
|
|
294
400
|
|
|
295
401
|
#[test]
|
|
296
402
|
fn transcript_token_refuses_second_inject() {
|
|
297
|
-
let case = WorkerCase::new("transcript", "
|
|
403
|
+
let case = WorkerCase::new("transcript", "claude");
|
|
298
404
|
let message_id = case.seed_leader_to_worker("transcript canary");
|
|
299
405
|
std::fs::write(
|
|
300
406
|
&case.rollout,
|