apm_core/wrapper/
custom.rs

1use std::io::Write;
2use std::path::{Path, PathBuf};
3use serde::Deserialize;
4use anyhow::Context;
5use super::{Wrapper, WrapperContext, CONTRACT_VERSION};
6
7#[derive(Debug, Clone, PartialEq)]
8enum ParserStrategy {
9    Canonical,
10    External,
11}
12
13impl ParserStrategy {
14    fn from_manifest(m: Option<&Manifest>) -> Self {
15        match m.and_then(|m| Some(m.parser.as_str())) {
16            Some("external") => Self::External,
17            _ => Self::Canonical,
18        }
19    }
20}
21
22/// Locate an executable binary by name or absolute path.
23/// For absolute paths: checks the file exists.
24/// For relative names: walks PATH entries and returns the first executable match.
25fn find_binary(cmd: &str) -> anyhow::Result<PathBuf> {
26    let p = Path::new(cmd);
27    if p.is_absolute() {
28        if p.is_file() {
29            return Ok(p.to_path_buf());
30        }
31        anyhow::bail!("parser binary not found: {}", cmd);
32    }
33    let path_var = std::env::var("PATH").unwrap_or_default();
34    for dir in std::env::split_paths(&path_var) {
35        let candidate = dir.join(cmd);
36        if !candidate.is_file() {
37            continue;
38        }
39        #[cfg(unix)]
40        {
41            use std::os::unix::fs::PermissionsExt;
42            if let Ok(meta) = candidate.metadata() {
43                if meta.permissions().mode() & 0o111 == 0 {
44                    continue;
45                }
46            }
47        }
48        return Ok(candidate);
49    }
50    anyhow::bail!("parser binary not found: {}", cmd);
51}
52
53fn default_contract_version() -> u32 { CONTRACT_VERSION }
54fn default_parser() -> String { "canonical".to_string() }
55
56#[derive(Debug, Deserialize, Clone)]
57pub struct Manifest {
58    #[serde(default)]
59    pub name: Option<String>,
60    #[serde(default = "default_contract_version")]
61    pub contract_version: u32,
62    #[serde(default = "default_parser")]
63    pub parser: String,
64    #[serde(default)]
65    pub parser_command: Option<String>,
66    /// When true, APM installs a `PreToolUse` hook that blocks writes outside
67    /// `APM_TICKET_WORKTREE`. Only applies to `parser = "canonical"` wrappers.
68    #[serde(default)]
69    pub enforce_worktree_isolation: bool,
70}
71
72pub enum WrapperKind {
73    Custom { script_path: PathBuf, manifest: Option<Manifest> },
74    Builtin(String),
75}
76
77pub struct CustomWrapper {
78    pub script_path: PathBuf,
79    pub manifest: Option<Manifest>,
80}
81
82fn check_contract_version(declared: u32, apm_version: u32, log_path: &Path) -> anyhow::Result<()> {
83    match declared.cmp(&apm_version) {
84        std::cmp::Ordering::Greater => anyhow::bail!(
85            "wrapper targets contract version {} but this APM build supports up to \
86             version {}; upgrade APM",
87            declared,
88            apm_version,
89        ),
90        std::cmp::Ordering::Less => {
91            if let Ok(mut f) = std::fs::OpenOptions::new()
92                .append(true)
93                .create(true)
94                .open(log_path)
95            {
96                let _ = writeln!(
97                    f,
98                    "[apm] warning: wrapper targets contract version {} but this APM \
99                     build is version {}; the wrapper may not use newer env vars",
100                    declared, apm_version,
101                );
102            }
103        }
104        std::cmp::Ordering::Equal => {}
105    }
106    Ok(())
107}
108
109impl Wrapper for CustomWrapper {
110    fn spawn(&self, ctx: &WrapperContext) -> anyhow::Result<std::process::Child> {
111        // Layer 2 spawn-time safety net: check contract_version unconditionally.
112        // Even if apm validate already passed, the manifest may have been edited
113        // between validate and this spawn call.
114        let declared = self.manifest.as_ref().map_or(1, |m| m.contract_version);
115        check_contract_version(declared, CONTRACT_VERSION, &ctx.log_path)
116            .map_err(|e| anyhow::anyhow!("wrapper '{}': {}", self.script_path.display(), e))?;
117
118        let apm_bin = super::resolve_apm_cli_bin();
119
120        // Write the path-guard hook for canonical wrappers that request isolation.
121        let enforce = self.manifest.as_ref().map_or(false, |m| m.enforce_worktree_isolation);
122        let strategy = ParserStrategy::from_manifest(self.manifest.as_ref());
123        if enforce && strategy == ParserStrategy::Canonical {
124            crate::wrapper::hook_config::write_hook_config(&ctx.worktree_path, &apm_bin)?;
125        }
126
127        let mut cmd = std::process::Command::new(&self.script_path);
128
129        set_apm_env(&mut cmd, ctx, &apm_bin);
130        for (k, v) in &ctx.extra_env {
131            cmd.env(k, v);
132        }
133        cmd.current_dir(&ctx.worktree_path);
134
135        #[cfg(unix)]
136        use std::os::unix::process::CommandExt;
137
138        match strategy {
139            ParserStrategy::Canonical => {
140                let log_file = std::fs::File::create(&ctx.log_path)?;
141                let log_clone = log_file.try_clone()?;
142                cmd.stdout(log_file);
143                cmd.stderr(log_clone);
144                #[cfg(unix)]
145                cmd.process_group(0);
146                Ok(cmd.spawn()?)
147            }
148            ParserStrategy::External => {
149                let manifest_path = self.script_path
150                    .parent()
151                    .map(|p| p.join("manifest.toml"))
152                    .unwrap_or_else(|| PathBuf::from("manifest.toml"));
153
154                // Require parser_command
155                let parser_cmd_str = self.manifest.as_ref()
156                    .and_then(|m| m.parser_command.as_deref())
157                    .ok_or_else(|| anyhow::anyhow!(
158                        "{}: parser = \"external\" but parser_command is not set",
159                        manifest_path.display()
160                    ))?
161                    .to_owned();
162
163                // Validate binary is findable before spawning any process
164                let parser_bin = find_binary(&parser_cmd_str)?;
165
166                // Open log file; clone for each stream that writes to it:
167                // 1. wrapper.stderr, 2. parser.stdout, 3. parser.stderr
168                let log_file_wrapper_stderr = std::fs::File::create(&ctx.log_path)?;
169                let log_file_parser_stdout = log_file_wrapper_stderr.try_clone()?;
170                let log_file_parser_stderr = log_file_wrapper_stderr.try_clone()?;
171
172                use std::process::Stdio;
173
174                // Spawn wrapper: stdout piped to feed parser stdin; stderr directly to log
175                cmd.stdout(Stdio::piped());
176                cmd.stderr(log_file_wrapper_stderr);
177                #[cfg(unix)]
178                cmd.process_group(0);
179                let mut wrapper_child = cmd.spawn()?;
180
181                let wrapper_stdout = wrapper_child.stdout.take()
182                    .ok_or_else(|| anyhow::anyhow!("failed to capture wrapper stdout pipe"))?;
183
184                // Reap wrapper in background thread; append diagnostic exit line to log
185                let log_path_clone = ctx.log_path.clone();
186                std::thread::spawn(move || {
187                    let status = wrapper_child.wait();
188                    if let Ok(mut f) = std::fs::OpenOptions::new()
189                        .append(true)
190                        .create(true)
191                        .open(&log_path_clone)
192                    {
193                        let status_str = match status {
194                            Ok(s) => format!("{s}"),
195                            Err(e) => format!("error: {e}"),
196                        };
197                        let _ = writeln!(f, "[apm] wrapper exited: {status_str}");
198                    }
199                });
200
201                // Spawn parser: stdin = wrapper stdout pipe; stdout/stderr -> log
202                let mut parser_cmd = std::process::Command::new(&parser_bin);
203                parser_cmd.stdin(Stdio::from(wrapper_stdout));
204                parser_cmd.stdout(log_file_parser_stdout);
205                parser_cmd.stderr(log_file_parser_stderr);
206                parser_cmd.current_dir(&ctx.worktree_path);
207                #[cfg(unix)]
208                parser_cmd.process_group(0);
209
210                Ok(parser_cmd.spawn()?)
211            }
212        }
213    }
214}
215
216fn set_apm_env(cmd: &mut std::process::Command, ctx: &WrapperContext, apm_bin: &str) {
217    cmd.env("APM_AGENT_NAME", &ctx.worker_name);
218    cmd.env("APM_TICKET_ID", &ctx.ticket_id);
219    cmd.env("APM_TICKET_BRANCH", &ctx.ticket_branch);
220    cmd.env("APM_TICKET_WORKTREE", ctx.worktree_path.to_string_lossy().as_ref());
221    cmd.env("APM_SYSTEM_PROMPT_FILE", ctx.system_prompt_file.to_string_lossy().as_ref());
222    cmd.env("APM_USER_MESSAGE_FILE", ctx.user_message_file.to_string_lossy().as_ref());
223    cmd.env("APM_SKIP_PERMISSIONS", if ctx.skip_permissions { "1" } else { "0" });
224    cmd.env("APM_MODEL", ctx.model.as_deref().unwrap_or(""));
225    cmd.env("APM_PROFILE", &ctx.profile);
226    if let Some(ref prefix) = ctx.role_prefix {
227        cmd.env("APM_ROLE_PREFIX", prefix);
228    }
229    cmd.env("APM_WRAPPER_VERSION", CONTRACT_VERSION.to_string());
230    cmd.env("APM_BIN", apm_bin);
231    for (k, v) in &ctx.options {
232        let env_key = format!(
233            "APM_OPT_{}",
234            k.to_uppercase().replace('.', "_").replace('-', "_")
235        );
236        cmd.env(&env_key, v);
237    }
238}
239
240pub(crate) fn find_script(root: &Path, name: &str) -> Option<PathBuf> {
241    let dir = root.join(".apm").join("agents").join(name);
242    let mut candidates: Vec<PathBuf> = std::fs::read_dir(&dir)
243        .ok()?
244        .filter_map(|e| e.ok())
245        .filter_map(|e| {
246            let path = e.path();
247            let fname = path.file_name()?.to_str()?.to_owned();
248            if !fname.starts_with("wrapper.") {
249                return None;
250            }
251            #[cfg(unix)]
252            {
253                use std::os::unix::fs::PermissionsExt;
254                let meta = path.metadata().ok()?;
255                if meta.permissions().mode() & 0o111 == 0 {
256                    return None;
257                }
258            }
259            Some(path)
260        })
261        .collect();
262    candidates.sort();
263    candidates.into_iter().next()
264}
265
266pub(crate) fn parse_manifest(root: &Path, name: &str) -> anyhow::Result<Option<Manifest>> {
267    let path = root.join(".apm").join("agents").join(name).join("manifest.toml");
268    if !path.exists() {
269        return Ok(None);
270    }
271    let content = std::fs::read_to_string(&path)
272        .with_context(|| format!("reading {}", path.display()))?;
273
274    #[derive(Deserialize)]
275    struct ManifestFile { wrapper: Manifest }
276
277    let file: ManifestFile = toml::from_str(&content)
278        .with_context(|| format!("parsing {}", path.display()))?;
279    Ok(Some(file.wrapper))
280}
281
282pub fn manifest_unknown_keys(root: &Path, name: &str) -> anyhow::Result<Vec<String>> {
283    let path = root.join(".apm").join("agents").join(name).join("manifest.toml");
284    if !path.exists() {
285        return Ok(vec![]);
286    }
287    let content = std::fs::read_to_string(&path)
288        .with_context(|| format!("reading {}", path.display()))?;
289    let table: toml::Value = content.parse::<toml::Value>()
290        .with_context(|| format!("parsing {}", path.display()))?;
291    let known = ["name", "contract_version", "parser", "parser_command", "enforce_worktree_isolation"];
292    let unknown = match table.get("wrapper").and_then(|v| v.as_table()) {
293        Some(t) => t.keys()
294            .filter(|k| !known.contains(&k.as_str()))
295            .cloned()
296            .collect(),
297        None => vec![],
298    };
299    Ok(unknown)
300}
301
302#[cfg(test)]
303mod tests {
304    use super::*;
305    use std::collections::HashMap;
306
307    fn make_ctx(wt: &std::path::Path, log: &std::path::Path) -> WrapperContext {
308        WrapperContext {
309            worker_name: "test-worker".to_string(),
310            ticket_id: "test-id".to_string(),
311            ticket_branch: "ticket/test-id".to_string(),
312            worktree_path: wt.to_path_buf(),
313            system_prompt_file: wt.join("sys.txt"),
314            user_message_file: wt.join("msg.txt"),
315            skip_permissions: false,
316            profile: "default".to_string(),
317            role_prefix: None,
318            options: HashMap::new(),
319            model: None,
320            log_path: log.to_path_buf(),
321            container: None,
322            extra_env: HashMap::new(),
323            root: wt.to_path_buf(),
324            keychain: HashMap::new(),
325            current_state: "test".to_string(),
326            command: None,
327        }
328    }
329
330    fn make_executable(path: &std::path::Path, content: &str) {
331        std::fs::write(path, content).unwrap();
332        #[cfg(unix)]
333        {
334            use std::os::unix::fs::PermissionsExt;
335            std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o755)).unwrap();
336        }
337    }
338
339    // --- resolve_wrapper tests (via wrapper::resolve_wrapper) ---
340
341    #[test]
342    fn resolve_wrapper_custom_shadows_builtin() {
343        let dir = tempfile::tempdir().unwrap();
344        let root = dir.path();
345        let agent_dir = root.join(".apm").join("agents").join("claude");
346        std::fs::create_dir_all(&agent_dir).unwrap();
347        make_executable(&agent_dir.join("wrapper.sh"), "#!/bin/sh\nexit 0\n");
348
349        let result = crate::wrapper::resolve_wrapper(root, "claude").unwrap();
350        assert!(matches!(result, Some(WrapperKind::Custom { .. })), "expected Custom variant");
351    }
352
353    #[test]
354    fn resolve_wrapper_fallback_to_builtin() {
355        let dir = tempfile::tempdir().unwrap();
356        let root = dir.path();
357        // No .apm/agents/claude/ dir
358
359        let result = crate::wrapper::resolve_wrapper(root, "claude").unwrap();
360        assert!(matches!(result, Some(WrapperKind::Builtin(ref n)) if n == "claude"),
361            "expected Builtin(claude)");
362    }
363
364    #[test]
365    fn resolve_wrapper_missing_returns_none() {
366        let dir = tempfile::tempdir().unwrap();
367        let root = dir.path();
368        // "bogus-agent" is neither a builtin nor a custom script
369
370        let result = crate::wrapper::resolve_wrapper(root, "bogus-agent").unwrap();
371        assert!(result.is_none(), "expected None");
372    }
373
374    #[test]
375    fn resolve_wrapper_nonexecutable_invisible() {
376        let dir = tempfile::tempdir().unwrap();
377        let root = dir.path();
378        let agent_dir = root.join(".apm").join("agents").join("claude");
379        std::fs::create_dir_all(&agent_dir).unwrap();
380
381        // Write non-executable wrapper.sh
382        let script = agent_dir.join("wrapper.sh");
383        std::fs::write(&script, "#!/bin/sh\nexit 0\n").unwrap();
384        #[cfg(unix)]
385        {
386            use std::os::unix::fs::PermissionsExt;
387            std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o644)).unwrap();
388        }
389
390        // Non-executable script is invisible; falls through to builtin
391        let result = crate::wrapper::resolve_wrapper(root, "claude").unwrap();
392        assert!(matches!(result, Some(WrapperKind::Builtin(ref n)) if n == "claude"),
393            "non-executable script should be invisible; expected fallback to Builtin(claude)");
394    }
395
396    // --- manifest tests ---
397
398    #[test]
399    fn manifest_parse_valid() {
400        let dir = tempfile::tempdir().unwrap();
401        let root = dir.path();
402        let agent_dir = root.join(".apm").join("agents").join("my-wrapper");
403        std::fs::create_dir_all(&agent_dir).unwrap();
404        std::fs::write(agent_dir.join("manifest.toml"),
405            "[wrapper]\nname = \"my-wrapper\"\ncontract_version = 1\nparser = \"canonical\"\n"
406        ).unwrap();
407
408        let m = parse_manifest(root, "my-wrapper").unwrap().unwrap();
409        assert_eq!(m.contract_version, 1);
410        assert_eq!(m.parser, "canonical");
411        assert_eq!(m.name.as_deref(), Some("my-wrapper"));
412        assert!(m.parser_command.is_none());
413    }
414
415    #[test]
416    fn manifest_parse_defaults() {
417        let dir = tempfile::tempdir().unwrap();
418        let root = dir.path();
419        let agent_dir = root.join(".apm").join("agents").join("my-wrapper");
420        std::fs::create_dir_all(&agent_dir).unwrap();
421        std::fs::write(agent_dir.join("manifest.toml"), "[wrapper]\n").unwrap();
422
423        let m = parse_manifest(root, "my-wrapper").unwrap().unwrap();
424        assert_eq!(m.contract_version, 1);
425        assert_eq!(m.parser, "canonical");
426        assert!(m.parser_command.is_none());
427    }
428
429    #[test]
430    fn manifest_parse_invalid_toml() {
431        let dir = tempfile::tempdir().unwrap();
432        let root = dir.path();
433        let agent_dir = root.join(".apm").join("agents").join("my-wrapper");
434        std::fs::create_dir_all(&agent_dir).unwrap();
435        std::fs::write(agent_dir.join("manifest.toml"), "[[[\nbad toml\n").unwrap();
436
437        assert!(parse_manifest(root, "my-wrapper").is_err(), "expected parse error");
438    }
439
440    #[test]
441    fn manifest_missing() {
442        let dir = tempfile::tempdir().unwrap();
443        let root = dir.path();
444        let agent_dir = root.join(".apm").join("agents").join("my-wrapper");
445        std::fs::create_dir_all(&agent_dir).unwrap();
446        // No manifest.toml
447
448        assert!(parse_manifest(root, "my-wrapper").unwrap().is_none());
449    }
450
451    #[test]
452    fn manifest_unknown_keys_detected() {
453        let dir = tempfile::tempdir().unwrap();
454        let root = dir.path();
455        let agent_dir = root.join(".apm").join("agents").join("my-wrapper");
456        std::fs::create_dir_all(&agent_dir).unwrap();
457        std::fs::write(agent_dir.join("manifest.toml"),
458            "[wrapper]\ncontract_version = 1\nunknown_key = \"foo\"\n"
459        ).unwrap();
460
461        let unknown = manifest_unknown_keys(root, "my-wrapper").unwrap();
462        assert!(unknown.contains(&"unknown_key".to_string()),
463            "expected unknown_key in {unknown:?}");
464    }
465
466    // --- check_contract_version unit tests ---
467
468    #[test]
469    fn check_version_equal() {
470        let log_dir = tempfile::tempdir().unwrap();
471        let log_path = log_dir.path().join("worker.log");
472        assert!(check_contract_version(1, 1, &log_path).is_ok());
473        // No log file created for equal versions
474        assert!(!log_path.exists() || std::fs::read_to_string(&log_path).unwrap().is_empty());
475    }
476
477    #[test]
478    fn check_version_older_writes_warning() {
479        let log_dir = tempfile::tempdir().unwrap();
480        let log_path = log_dir.path().join("worker.log");
481        // declared=1 is older than apm_version=2 → warning, Ok
482        let result = check_contract_version(1, 2, &log_path);
483        assert!(result.is_ok(), "expected Ok for older version");
484        let content = std::fs::read_to_string(&log_path).unwrap_or_default();
485        assert!(content.contains("warning"), "log must contain 'warning': {content}");
486        assert!(content.contains('1'), "log must contain declared version 1: {content}");
487        assert!(content.contains('2'), "log must contain apm version 2: {content}");
488    }
489
490    #[test]
491    fn check_version_too_high_returns_err() {
492        let log_dir = tempfile::tempdir().unwrap();
493        let log_path = log_dir.path().join("worker.log");
494        let result = check_contract_version(2, 1, &log_path);
495        assert!(result.is_err(), "expected Err for version > apm");
496        let msg = result.unwrap_err().to_string();
497        assert!(msg.contains("upgrade APM"), "error must mention 'upgrade APM': {msg}");
498        assert!(msg.contains('2'), "error must mention declared version 2: {msg}");
499        assert!(msg.contains('1'), "error must mention apm version 1: {msg}");
500    }
501
502    #[test]
503    fn default_contract_version_tracks_apm_version() {
504        // Ensures that bumping CONTRACT_VERSION also updates the manifest serde
505        // default, so older manifests don't silently parse with a stale version.
506        assert_eq!(default_contract_version(), CONTRACT_VERSION);
507    }
508
509    // --- ParserStrategy tests ---
510
511    #[test]
512    fn parser_strategy_defaults_to_canonical() {
513        assert_eq!(ParserStrategy::from_manifest(None), ParserStrategy::Canonical);
514    }
515
516    #[test]
517    fn parser_strategy_explicit_canonical() {
518        let m = Manifest {
519            name: None,
520            contract_version: 1,
521            parser: "canonical".to_string(),
522            parser_command: None,
523            enforce_worktree_isolation: false,
524        };
525        assert_eq!(ParserStrategy::from_manifest(Some(&m)), ParserStrategy::Canonical);
526    }
527
528    #[test]
529    fn parser_strategy_external() {
530        let m = Manifest {
531            name: None,
532            contract_version: 1,
533            parser: "external".to_string(),
534            parser_command: Some("my-parser".to_string()),
535            enforce_worktree_isolation: false,
536        };
537        assert_eq!(ParserStrategy::from_manifest(Some(&m)), ParserStrategy::External);
538    }
539
540    #[test]
541    fn parser_strategy_unknown_falls_back_to_canonical() {
542        let m = Manifest {
543            name: None,
544            contract_version: 1,
545            parser: "foobar".to_string(),
546            parser_command: None,
547            enforce_worktree_isolation: false,
548        };
549        assert_eq!(ParserStrategy::from_manifest(Some(&m)), ParserStrategy::Canonical);
550    }
551
552    #[test]
553    fn spawn_external_missing_parser_command() {
554        use std::os::unix::fs::PermissionsExt;
555
556        let wt = tempfile::tempdir().unwrap();
557        let log_dir = tempfile::tempdir().unwrap();
558        let log_path = log_dir.path().join("worker.log");
559
560        let script = wt.path().join("wrapper.sh");
561        std::fs::write(&script, "#!/bin/sh\nexit 0\n").unwrap();
562        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
563
564        let manifest = Manifest {
565            name: None,
566            contract_version: 1,
567            parser: "external".to_string(),
568            parser_command: None,
569            enforce_worktree_isolation: false,
570        };
571        let wrapper = CustomWrapper {
572            script_path: script,
573            manifest: Some(manifest),
574        };
575
576        let ctx = make_ctx(wt.path(), &log_path);
577        let err = wrapper.spawn(&ctx).unwrap_err();
578        let msg = err.to_string();
579        assert!(msg.contains("parser_command"), "error must mention parser_command: {msg}");
580        assert!(msg.contains("not set"), "error must mention 'not set': {msg}");
581    }
582
583    #[test]
584    fn spawn_external_binary_not_found() {
585        use std::os::unix::fs::PermissionsExt;
586
587        let wt = tempfile::tempdir().unwrap();
588        let log_dir = tempfile::tempdir().unwrap();
589        let log_path = log_dir.path().join("worker.log");
590
591        let script = wt.path().join("wrapper.sh");
592        std::fs::write(&script, "#!/bin/sh\nexit 0\n").unwrap();
593        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
594
595        let manifest = Manifest {
596            name: None,
597            contract_version: 1,
598            parser: "external".to_string(),
599            parser_command: Some("nonexistent-binary-xyzzy-2803".to_string()),
600            enforce_worktree_isolation: false,
601        };
602        let wrapper = CustomWrapper {
603            script_path: script,
604            manifest: Some(manifest),
605        };
606
607        let ctx = make_ctx(wt.path(), &log_path);
608        let err = wrapper.spawn(&ctx).unwrap_err();
609        let msg = err.to_string();
610        assert!(
611            msg.contains("nonexistent-binary-xyzzy-2803"),
612            "error must name the missing binary: {msg}"
613        );
614    }
615
616    #[test]
617    fn spawn_rejects_contract_version_gt_1() {
618        use std::os::unix::fs::PermissionsExt;
619
620        let wt = tempfile::tempdir().unwrap();
621        let log_dir = tempfile::tempdir().unwrap();
622
623        // Create a script (won't be reached due to early bail)
624        let script = wt.path().join("wrapper.sh");
625        std::fs::write(&script, "#!/bin/sh\nexit 0\n").unwrap();
626        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
627
628        let manifest = Manifest {
629            name: None,
630            contract_version: 2,
631            parser: "canonical".to_string(),
632            parser_command: None,
633            enforce_worktree_isolation: false,
634        };
635
636        let wrapper = CustomWrapper {
637            script_path: script,
638            manifest: Some(manifest),
639        };
640
641        let ctx = make_ctx(wt.path(), &log_dir.path().join("worker.log"));
642        let err = wrapper.spawn(&ctx).unwrap_err();
643        let msg = err.to_string();
644        assert!(msg.contains("upgrade APM"),
645            "error message must mention 'upgrade APM': {msg}");
646    }
647}
apm_core/wrapper/custom.rs

apm_core/wrapper/
custom.rs
