1use rusqlite::{params, Connection, OptionalExtension, Row};
2
3#[derive(Debug, Clone)]
4pub struct BashTaskRow {
5 pub harness: String,
6 pub session_id: String,
7 pub task_id: String,
8 pub project_key: String,
9 pub command: String,
10 pub cwd: String,
11 pub status: String,
12 pub exit_code: Option<i32>,
13 pub pid: Option<i64>,
14 pub pgid: Option<i64>,
15 pub started_at: i64,
16 pub completed_at: Option<i64>,
17 pub stdout_path: Option<String>,
18 pub stderr_path: Option<String>,
19 pub compressed: bool,
20 pub timeout_ms: Option<i64>,
21 pub completion_delivered: bool,
22 pub output_bytes: Option<i64>,
23 pub metadata: String,
24}
25
26pub fn upsert_bash_task(conn: &Connection, row: &BashTaskRow) -> rusqlite::Result<()> {
27 conn.execute(
28 "INSERT INTO bash_tasks (
29 harness, session_id, task_id, project_key, command, cwd, status,
30 exit_code, pid, pgid, started_at, completed_at, stdout_path, stderr_path,
31 compressed, timeout_ms, completion_delivered, output_bytes, metadata
32 ) VALUES (
33 ?1, ?2, ?3, ?4, ?5, ?6, ?7,
34 ?8, ?9, ?10, ?11, ?12, ?13, ?14,
35 ?15, ?16, ?17, ?18, ?19
36 )
37 ON CONFLICT(harness, session_id, task_id) DO UPDATE SET
38 project_key = excluded.project_key,
39 command = excluded.command,
40 cwd = excluded.cwd,
41 status = excluded.status,
42 exit_code = excluded.exit_code,
43 pid = excluded.pid,
44 pgid = excluded.pgid,
45 started_at = excluded.started_at,
46 completed_at = excluded.completed_at,
47 stdout_path = excluded.stdout_path,
48 stderr_path = excluded.stderr_path,
49 compressed = excluded.compressed,
50 timeout_ms = excluded.timeout_ms,
51 completion_delivered = excluded.completion_delivered,
52 output_bytes = excluded.output_bytes,
53 metadata = excluded.metadata",
54 params![
55 row.harness,
56 row.session_id,
57 row.task_id,
58 row.project_key,
59 row.command,
60 row.cwd,
61 row.status,
62 row.exit_code,
63 row.pid,
64 row.pgid,
65 row.started_at,
66 row.completed_at,
67 row.stdout_path,
68 row.stderr_path,
69 row.compressed,
70 row.timeout_ms,
71 row.completion_delivered,
72 row.output_bytes,
73 row.metadata,
74 ],
75 )?;
76 Ok(())
77}
78
79pub fn delete_delivered_terminal_bash_task(
80 conn: &Connection,
81 harness: &str,
82 session_id: &str,
83 task_id: &str,
84 reason: &str,
85) -> rusqlite::Result<usize> {
86 let deleted = conn.execute(
87 "DELETE FROM bash_tasks
88 WHERE harness = ?1 AND session_id = ?2 AND task_id = ?3
89 AND completion_delivered = 1
90 AND status IN ('completed', 'failed', 'killed', 'timed_out', 'fate_unknown')",
91 params![harness, session_id, task_id],
92 )?;
93 if deleted > 0 {
96 crate::slog_warn!("bash task row deleted: task_id={task_id} reason={reason}");
97 }
98 Ok(deleted)
99}
100
101pub fn get_bash_task(
102 conn: &Connection,
103 harness: &str,
104 session_id: &str,
105 task_id: &str,
106) -> rusqlite::Result<Option<BashTaskRow>> {
107 conn.query_row(
108 "SELECT harness, session_id, task_id, project_key, command, cwd, status,
109 exit_code, pid, pgid, started_at, completed_at, stdout_path, stderr_path,
110 compressed, timeout_ms, completion_delivered, output_bytes, metadata
111 FROM bash_tasks
112 WHERE harness = ?1 AND session_id = ?2 AND task_id = ?3",
113 params![harness, session_id, task_id],
114 map_bash_task_row,
115 )
116 .optional()
117}
118
119pub fn list_bash_tasks_for_session(
120 conn: &Connection,
121 harness: &str,
122 session_id: &str,
123) -> rusqlite::Result<Vec<BashTaskRow>> {
124 let mut stmt = conn.prepare(
125 "SELECT harness, session_id, task_id, project_key, command, cwd, status,
126 exit_code, pid, pgid, started_at, completed_at, stdout_path, stderr_path,
127 compressed, timeout_ms, completion_delivered, output_bytes, metadata
128 FROM bash_tasks
129 WHERE harness = ?1 AND session_id = ?2
130 ORDER BY started_at ASC, task_id ASC",
131 )?;
132
133 let rows = stmt
134 .query_map(params![harness, session_id], map_bash_task_row)?
135 .collect();
136 rows
137}
138
139pub fn list_bash_tasks_by_id(
140 conn: &Connection,
141 harness: &str,
142 task_id: &str,
143) -> rusqlite::Result<Vec<BashTaskRow>> {
144 let mut stmt = conn.prepare(
145 "SELECT harness, session_id, task_id, project_key, command, cwd, status,
146 exit_code, pid, pgid, started_at, completed_at, stdout_path, stderr_path,
147 compressed, timeout_ms, completion_delivered, output_bytes, metadata
148 FROM bash_tasks
149 WHERE harness = ?1 AND task_id = ?2
150 ORDER BY started_at DESC",
151 )?;
152 let rows = stmt
153 .query_map(params![harness, task_id], map_bash_task_row)?
154 .collect();
155 rows
156}
157
158pub fn list_replayable_bash_tasks_for_project(
159 conn: &Connection,
160 harness: &str,
161 project_key: &str,
162) -> rusqlite::Result<Vec<BashTaskRow>> {
163 let mut stmt = conn.prepare(
164 "SELECT harness, session_id, task_id, project_key, command, cwd, status,
165 exit_code, pid, pgid, started_at, completed_at, stdout_path, stderr_path,
166 compressed, timeout_ms, completion_delivered, output_bytes, metadata
167 FROM bash_tasks
168 WHERE harness = ?1 AND project_key = ?2
169 AND (status NOT IN ('completed', 'failed', 'killed', 'timed_out', 'fate_unknown')
170 OR completion_delivered = 0)
171 ORDER BY started_at ASC, task_id ASC",
172 )?;
173 let rows = stmt
174 .query_map(params![harness, project_key], map_bash_task_row)?
175 .collect();
176 rows
177}
178
179pub fn find_bash_task_for_project(
180 conn: &Connection,
181 harness: &str,
182 project_key: &str,
183 task_id: &str,
184) -> rusqlite::Result<Option<BashTaskRow>> {
185 conn.query_row(
186 "SELECT harness, session_id, task_id, project_key, command, cwd, status,
187 exit_code, pid, pgid, started_at, completed_at, stdout_path, stderr_path,
188 compressed, timeout_ms, completion_delivered, output_bytes, metadata
189 FROM bash_tasks
190 WHERE harness = ?1 AND project_key = ?2 AND task_id = ?3
191 ORDER BY started_at DESC
192 LIMIT 1",
193 params![harness, project_key, task_id],
194 map_bash_task_row,
195 )
196 .optional()
197}
198
199fn map_bash_task_row(row: &Row<'_>) -> rusqlite::Result<BashTaskRow> {
200 Ok(BashTaskRow {
201 harness: row.get(0)?,
202 session_id: row.get(1)?,
203 task_id: row.get(2)?,
204 project_key: row.get(3)?,
205 command: row.get(4)?,
206 cwd: row.get(5)?,
207 status: row.get(6)?,
208 exit_code: row.get(7)?,
209 pid: row.get(8)?,
210 pgid: row.get(9)?,
211 started_at: row.get(10)?,
212 completed_at: row.get(11)?,
213 stdout_path: row.get(12)?,
214 stderr_path: row.get(13)?,
215 compressed: row.get::<_, i64>(14)? != 0,
216 timeout_ms: row.get(15)?,
217 completion_delivered: row.get::<_, i64>(16)? != 0,
218 output_bytes: row.get(17)?,
219 metadata: row.get::<_, Option<String>>(18)?.unwrap_or_default(),
220 })
221}