1. 1#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
2. 2
3. 3//! Integration coverage for docs/design/34-channel-onboarding.md Phase 2:
4. 4//! an allowlist entry approved for a workspace other than the gateway's
5. 5//! own default actually runs a session rooted at that other workspace,
6. 6//! not just its provider/model.
7. 7//!
8. 8//! `VAK_HOME` is set for the whole process below so pooled Cores started
9. 9//! for the non-default workspace resolve their sessions_home the normal
10. 10//! way (`Core::new_with_trust`, unmodified) inside a hermetic tempdir
11. 11//! instead of the real user's data home. This file has exactly one test
12. 12//! so that process-wide env mutation cannot race a sibling test.
13. 13
14. 14use std::sync::Arc;
15. 15
16. 16use vak_core::Core;
17. 17use vak_llm::stream;
18. 18use vak_llm::types::{AssistantMessage, ChatRequest, ContentBlock, StopReason, Usage};
19. 19use vak_llm::{EventStream, LlmError, Provider};
20. 20
21. 21struct NoCred;
22. 22
23. 23#[async_trait::async_trait]
24. 24impl Provider for NoCred {
25. 25 fn name(&self) -> &str {
26. 26 "scripted"
27. 27 }
28. 28 async fn stream(
29. 29 &self,
30. 30 _request: ChatRequest,
31. 31 _cancel: tokio_util::sync::CancellationToken,
32. 32 ) -> Result<EventStream, LlmError> {
33. 33 let (mut sink, rx) = stream::channel(64);
34. 34 let m = AssistantMessage {
35. 35 content: vec![ContentBlock::text("unused")],
36. 36 stop_reason: StopReason::EndTurn,
37. 37 usage: Usage::default(),
38. 38 model: "test-model".into(),
39. 39 response_id: None,
40. 40 };
41. 41 sink.close_message(m).await;
42. 42 Ok(rx)
43. 43 }
44. 44}
45. 45
46. 46#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
47. 47async fn approved_entry_routes_to_its_own_workspace_core() {
48. 48 let vak_home = tempfile::tempdir().unwrap();
49. 49 vak_config::paths::set_home_override(vak_home.path());
50. 50
51. 51 let default_dir = tempfile::tempdir().unwrap();
52. 52 let other_dir = tempfile::tempdir().unwrap();
53. 53 let _ = std::fs::create_dir_all(other_dir.path());
54. 54
55. 55 let default_cwd = default_dir.path().to_path_buf();
56. 56 let _ = std::fs::create_dir_all(default_cwd.join(".vak"));
57. 57 let _ = std::fs::write(
58. 58 default_cwd.join(".vak/config.toml"),
59. 59 "[memory]\nreflection = false\n[gateway]\nchat_allowlist_open = false\n",
60. 60 );
61. 61 let core = Core::new_with_trust(default_cwd.clone(), true).unwrap();
62. 62 core.set_sessions_home(vak_home.path().join("default-home"));
63. 63 core.set_provider_instance(Arc::new(NoCred));
64. 64
65. 65 let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
66. 66 let addr = listener.local_addr().unwrap();
67. 67 let (app, token) = vak_server::secured_router_with(core, true);
68. 68 let _server = tokio::spawn(async move {
69. 69 axum::serve(listener, app).await.unwrap();
70. 70 });
71. 71 let base = format!("http://{addr}");
72. 72
73. 73 let client = reqwest::ClientBuilder::new()
74. 74 .default_headers({
75. 75 let mut h = reqwest::header::HeaderMap::new();
76. 76 h.insert(
77. 77 reqwest::header::AUTHORIZATION,
78. 78 format!("Bearer {token}").parse().unwrap(),
79. 79 );
80. 80 h
81. 81 })
82. 82 .build()
83. 83 .unwrap();
84. 84
85. 85 // First message: unknown key becomes pending, not silently allowed.
86. 86 let msg = serde_json::json!({
87. 87 "surface": "webhook", "chat": "ci-other-ws", "sender": "bot",
88. 88 "text": "hello", "wait": false,
89. 89 });
90. 90 let res = client
91. 91 .post(format!("{base}/gateway/inbound"))
92. 92 .json(&msg)
93. 93 .send()
94. 94 .await
95. 95 .unwrap();
96. 96 assert_eq!(res.status(), 403);
97. 97 let body: serde_json::Value = res.json().await.unwrap();
98. 98 assert_eq!(body["state"], "pending");
99. 99
100. 100 // Operator approves, explicitly naming a workspace other than the
101. 101 // gateway's own default — the Phase 1 fix for silent inheritance.
102. 102 let approve_res = client
103. 103 .post(format!(
104. 104 "{base}/admin/api/gateway/allowlist/webhook%3Aci-other-ws/approve"
105. 105 ))
106. 106 .json(&serde_json::json!({ "workspace": other_dir.path() }))
107. 107 .send()
108. 108 .await
109. 109 .unwrap();
110. 110 assert_eq!(approve_res.status(), 200, "approve must succeed");
111. 111
112. 112 // Second message: now allowed. Provider auth still fails (no credential
113. 113 // configured / injected for the pooled Core), so the turn itself can't
114. 114 // finish — but session creation happens *before* that check, so the
115. 115 // pooled Core for `other_dir` must already have started and minted a
116. 116 // session there by the time we inspect it.
117. 117 let res = client
118. 118 .post(format!("{base}/gateway/inbound"))
119. 119 .json(&msg)
120. 120 .send()
121. 121 .await
122. 122 .unwrap();
123. 123 assert_eq!(
124. 124 res.status(),
125. 125 503,
126. 126 "session should have been created against the other workspace's pooled Core \
127. 127 before the provider-credential check fails"
128. 128 );
129. 129
130. 130 // Confirm: the pool now reports the other workspace as warm.
131. 131 let status: serde_json::Value = client
132. 132 .get(format!("{base}/admin/api/gateway/status"))
133. 133 .send()
134. 134 .await
135. 135 .unwrap()
136. 136 .json()
137. 137 .await
138. 138 .unwrap();
139. 139 let pool_entries = status["core_pool"]["entries"].as_array().unwrap();
140. 140 let other_canonical = other_dir.path().canonicalize().unwrap();
141. 141 assert!(
142. 142 pool_entries
143. 143 .iter()
144. 144 .any(|e| e["workspace"].as_str() == Some(other_canonical.to_str().unwrap())),
145. 145 "expected {other_canonical:?} to appear warm in the core pool, got {pool_entries:?}"
146. 146 );
147. 147
148. 148 // Confirm: the session actually minted lives under the OTHER
149. 149 // workspace's sessions_home (the normal, unmodified `Core::new_with_trust`
150. 150 // resolution under VAK_HOME), with a ledger header whose cwd is that
151. 151 // workspace — not the gateway's own default cwd.
152. 152 let mut found_header_cwd: Option<String> = None;
153. 153 for entry in walkdir::WalkDir::new(vak_home.path()).into_iter().flatten() {
154. 154 let path = entry.path();
155. 155 if path.extension().and_then(|e| e.to_str()) != Some("jsonl") {
156. 156 continue;
157. 157 }
158. 158 let Ok(raw) = std::fs::read_to_string(path) else {
159. 159 continue;
160. 160 };
161. 161 if let Some(first_line) = raw.lines().next()
162. 162 && let Ok(v) = serde_json::from_str::<serde_json::Value>(first_line)
163. 163 && let Some(cwd) = v.get("cwd").and_then(|c| c.as_str())
164. 164 {
165. 165 found_header_cwd = Some(cwd.to_string());
166. 166 }
167. 167 }
168. 168 assert_eq!(
169. 169 found_header_cwd.as_deref(),
170. 170 Some(other_canonical.to_str().unwrap()),
171. 171 "session ledger header cwd must be the approved entry's own workspace, \
172. 172 not the gateway's default"
173. 173 );
174. 174
175. 175 // Drop the pin so a later test in this binary resolves normally.
176. 176 vak_config::clear_override("VAK_HOME");
177. 177}
178. 178