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_PROFILE", &ctx.profile);
225    if let Some(ref prefix) = ctx.role_prefix {
226        cmd.env("APM_ROLE_PREFIX", prefix);
227    }
228    cmd.env("APM_WRAPPER_VERSION", CONTRACT_VERSION.to_string());
229    cmd.env("APM_BIN", apm_bin);
230    for (k, v) in &ctx.options {
231        let env_key = format!(
232            "APM_OPT_{}",
233            k.to_uppercase().replace('.', "_").replace('-', "_")
234        );
235        cmd.env(&env_key, v);
236    }
237}
238
239pub(crate) fn find_script(root: &Path, name: &str) -> Option<PathBuf> {
240    let dir = root.join(".apm").join("agents").join(name);
241    let mut candidates: Vec<PathBuf> = std::fs::read_dir(&dir)
242        .ok()?
243        .filter_map(|e| e.ok())
244        .filter_map(|e| {
245            let path = e.path();
246            let fname = path.file_name()?.to_str()?.to_owned();
247            if !fname.starts_with("wrapper.") {
248                return None;
249            }
250            #[cfg(unix)]
251            {
252                use std::os::unix::fs::PermissionsExt;
253                let meta = path.metadata().ok()?;
254                if meta.permissions().mode() & 0o111 == 0 {
255                    return None;
256                }
257            }
258            Some(path)
259        })
260        .collect();
261    candidates.sort();
262    candidates.into_iter().next()
263}
264
265pub(crate) fn parse_manifest(root: &Path, name: &str) -> anyhow::Result<Option<Manifest>> {
266    let path = root.join(".apm").join("agents").join(name).join("manifest.toml");
267    if !path.exists() {
268        return Ok(None);
269    }
270    let content = std::fs::read_to_string(&path)
271        .with_context(|| format!("reading {}", path.display()))?;
272
273    #[derive(Deserialize)]
274    struct ManifestFile { wrapper: Manifest }
275
276    let file: ManifestFile = toml::from_str(&content)
277        .with_context(|| format!("parsing {}", path.display()))?;
278    Ok(Some(file.wrapper))
279}
280
281pub fn manifest_unknown_keys(root: &Path, name: &str) -> anyhow::Result<Vec<String>> {
282    let path = root.join(".apm").join("agents").join(name).join("manifest.toml");
283    if !path.exists() {
284        return Ok(vec![]);
285    }
286    let content = std::fs::read_to_string(&path)
287        .with_context(|| format!("reading {}", path.display()))?;
288    let table: toml::Value = content.parse::<toml::Value>()
289        .with_context(|| format!("parsing {}", path.display()))?;
290    let known = ["name", "contract_version", "parser", "parser_command", "enforce_worktree_isolation"];
291    let unknown = match table.get("wrapper").and_then(|v| v.as_table()) {
292        Some(t) => t.keys()
293            .filter(|k| !known.contains(&k.as_str()))
294            .cloned()
295            .collect(),
296        None => vec![],
297    };
298    Ok(unknown)
299}
300
301#[cfg(test)]
302mod tests {
303    use super::*;
304    use std::collections::HashMap;
305
306    fn make_ctx(wt: &std::path::Path, log: &std::path::Path) -> WrapperContext {
307        WrapperContext {
308            worker_name: "test-worker".to_string(),
309            ticket_id: "test-id".to_string(),
310            ticket_branch: "ticket/test-id".to_string(),
311            worktree_path: wt.to_path_buf(),
312            system_prompt_file: wt.join("sys.txt"),
313            user_message_file: wt.join("msg.txt"),
314            skip_permissions: false,
315            profile: "default".to_string(),
316            role_prefix: None,
317            options: HashMap::new(),
318            model: None,
319            log_path: log.to_path_buf(),
320            container: None,
321            extra_env: HashMap::new(),
322            root: wt.to_path_buf(),
323            keychain: HashMap::new(),
324            current_state: "test".to_string(),
325            command: None,
326        }
327    }
328
329    fn make_executable(path: &std::path::Path, content: &str) {
330        std::fs::write(path, content).unwrap();
331        #[cfg(unix)]
332        {
333            use std::os::unix::fs::PermissionsExt;
334            std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o755)).unwrap();
335        }
336    }
337
338    // --- resolve_wrapper tests (via wrapper::resolve_wrapper) ---
339
340    #[test]
341    fn resolve_wrapper_custom_shadows_builtin() {
342        let dir = tempfile::tempdir().unwrap();
343        let root = dir.path();
344        let agent_dir = root.join(".apm").join("agents").join("claude");
345        std::fs::create_dir_all(&agent_dir).unwrap();
346        make_executable(&agent_dir.join("wrapper.sh"), "#!/bin/sh\nexit 0\n");
347
348        let result = crate::wrapper::resolve_wrapper(root, "claude").unwrap();
349        assert!(matches!(result, Some(WrapperKind::Custom { .. })), "expected Custom variant");
350    }
351
352    #[test]
353    fn resolve_wrapper_fallback_to_builtin() {
354        let dir = tempfile::tempdir().unwrap();
355        let root = dir.path();
356        // No .apm/agents/claude/ dir
357
358        let result = crate::wrapper::resolve_wrapper(root, "claude").unwrap();
359        assert!(matches!(result, Some(WrapperKind::Builtin(ref n)) if n == "claude"),
360            "expected Builtin(claude)");
361    }
362
363    #[test]
364    fn resolve_wrapper_missing_returns_none() {
365        let dir = tempfile::tempdir().unwrap();
366        let root = dir.path();
367        // "bogus-agent" is neither a builtin nor a custom script
368
369        let result = crate::wrapper::resolve_wrapper(root, "bogus-agent").unwrap();
370        assert!(result.is_none(), "expected None");
371    }
372
373    #[test]
374    fn resolve_wrapper_nonexecutable_invisible() {
375        let dir = tempfile::tempdir().unwrap();
376        let root = dir.path();
377        let agent_dir = root.join(".apm").join("agents").join("claude");
378        std::fs::create_dir_all(&agent_dir).unwrap();
379
380        // Write non-executable wrapper.sh
381        let script = agent_dir.join("wrapper.sh");
382        std::fs::write(&script, "#!/bin/sh\nexit 0\n").unwrap();
383        #[cfg(unix)]
384        {
385            use std::os::unix::fs::PermissionsExt;
386            std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o644)).unwrap();
387        }
388
389        // Non-executable script is invisible; falls through to builtin
390        let result = crate::wrapper::resolve_wrapper(root, "claude").unwrap();
391        assert!(matches!(result, Some(WrapperKind::Builtin(ref n)) if n == "claude"),
392            "non-executable script should be invisible; expected fallback to Builtin(claude)");
393    }
394
395    // --- manifest tests ---
396
397    #[test]
398    fn manifest_parse_valid() {
399        let dir = tempfile::tempdir().unwrap();
400        let root = dir.path();
401        let agent_dir = root.join(".apm").join("agents").join("my-wrapper");
402        std::fs::create_dir_all(&agent_dir).unwrap();
403        std::fs::write(agent_dir.join("manifest.toml"),
404            "[wrapper]\nname = \"my-wrapper\"\ncontract_version = 1\nparser = \"canonical\"\n"
405        ).unwrap();
406
407        let m = parse_manifest(root, "my-wrapper").unwrap().unwrap();
408        assert_eq!(m.contract_version, 1);
409        assert_eq!(m.parser, "canonical");
410        assert_eq!(m.name.as_deref(), Some("my-wrapper"));
411        assert!(m.parser_command.is_none());
412    }
413
414    #[test]
415    fn manifest_parse_defaults() {
416        let dir = tempfile::tempdir().unwrap();
417        let root = dir.path();
418        let agent_dir = root.join(".apm").join("agents").join("my-wrapper");
419        std::fs::create_dir_all(&agent_dir).unwrap();
420        std::fs::write(agent_dir.join("manifest.toml"), "[wrapper]\n").unwrap();
421
422        let m = parse_manifest(root, "my-wrapper").unwrap().unwrap();
423        assert_eq!(m.contract_version, 1);
424        assert_eq!(m.parser, "canonical");
425        assert!(m.parser_command.is_none());
426    }
427
428    #[test]
429    fn manifest_parse_invalid_toml() {
430        let dir = tempfile::tempdir().unwrap();
431        let root = dir.path();
432        let agent_dir = root.join(".apm").join("agents").join("my-wrapper");
433        std::fs::create_dir_all(&agent_dir).unwrap();
434        std::fs::write(agent_dir.join("manifest.toml"), "[[[\nbad toml\n").unwrap();
435
436        assert!(parse_manifest(root, "my-wrapper").is_err(), "expected parse error");
437    }
438
439    #[test]
440    fn manifest_missing() {
441        let dir = tempfile::tempdir().unwrap();
442        let root = dir.path();
443        let agent_dir = root.join(".apm").join("agents").join("my-wrapper");
444        std::fs::create_dir_all(&agent_dir).unwrap();
445        // No manifest.toml
446
447        assert!(parse_manifest(root, "my-wrapper").unwrap().is_none());
448    }
449
450    #[test]
451    fn manifest_unknown_keys_detected() {
452        let dir = tempfile::tempdir().unwrap();
453        let root = dir.path();
454        let agent_dir = root.join(".apm").join("agents").join("my-wrapper");
455        std::fs::create_dir_all(&agent_dir).unwrap();
456        std::fs::write(agent_dir.join("manifest.toml"),
457            "[wrapper]\ncontract_version = 1\nunknown_key = \"foo\"\n"
458        ).unwrap();
459
460        let unknown = manifest_unknown_keys(root, "my-wrapper").unwrap();
461        assert!(unknown.contains(&"unknown_key".to_string()),
462            "expected unknown_key in {unknown:?}");
463    }
464
465    // --- check_contract_version unit tests ---
466
467    #[test]
468    fn check_version_equal() {
469        let log_dir = tempfile::tempdir().unwrap();
470        let log_path = log_dir.path().join("worker.log");
471        assert!(check_contract_version(1, 1, &log_path).is_ok());
472        // No log file created for equal versions
473        assert!(!log_path.exists() || std::fs::read_to_string(&log_path).unwrap().is_empty());
474    }
475
476    #[test]
477    fn check_version_older_writes_warning() {
478        let log_dir = tempfile::tempdir().unwrap();
479        let log_path = log_dir.path().join("worker.log");
480        // declared=1 is older than apm_version=2 → warning, Ok
481        let result = check_contract_version(1, 2, &log_path);
482        assert!(result.is_ok(), "expected Ok for older version");
483        let content = std::fs::read_to_string(&log_path).unwrap_or_default();
484        assert!(content.contains("warning"), "log must contain 'warning': {content}");
485        assert!(content.contains('1'), "log must contain declared version 1: {content}");
486        assert!(content.contains('2'), "log must contain apm version 2: {content}");
487    }
488
489    #[test]
490    fn check_version_too_high_returns_err() {
491        let log_dir = tempfile::tempdir().unwrap();
492        let log_path = log_dir.path().join("worker.log");
493        let result = check_contract_version(2, 1, &log_path);
494        assert!(result.is_err(), "expected Err for version > apm");
495        let msg = result.unwrap_err().to_string();
496        assert!(msg.contains("upgrade APM"), "error must mention 'upgrade APM': {msg}");
497        assert!(msg.contains('2'), "error must mention declared version 2: {msg}");
498        assert!(msg.contains('1'), "error must mention apm version 1: {msg}");
499    }
500
501    #[test]
502    fn default_contract_version_tracks_apm_version() {
503        // Ensures that bumping CONTRACT_VERSION also updates the manifest serde
504        // default, so older manifests don't silently parse with a stale version.
505        assert_eq!(default_contract_version(), CONTRACT_VERSION);
506    }
507
508    // --- ParserStrategy tests ---
509
510    #[test]
511    fn parser_strategy_defaults_to_canonical() {
512        assert_eq!(ParserStrategy::from_manifest(None), ParserStrategy::Canonical);
513    }
514
515    #[test]
516    fn parser_strategy_explicit_canonical() {
517        let m = Manifest {
518            name: None,
519            contract_version: 1,
520            parser: "canonical".to_string(),
521            parser_command: None,
522            enforce_worktree_isolation: false,
523        };
524        assert_eq!(ParserStrategy::from_manifest(Some(&m)), ParserStrategy::Canonical);
525    }
526
527    #[test]
528    fn parser_strategy_external() {
529        let m = Manifest {
530            name: None,
531            contract_version: 1,
532            parser: "external".to_string(),
533            parser_command: Some("my-parser".to_string()),
534            enforce_worktree_isolation: false,
535        };
536        assert_eq!(ParserStrategy::from_manifest(Some(&m)), ParserStrategy::External);
537    }
538
539    #[test]
540    fn parser_strategy_unknown_falls_back_to_canonical() {
541        let m = Manifest {
542            name: None,
543            contract_version: 1,
544            parser: "foobar".to_string(),
545            parser_command: None,
546            enforce_worktree_isolation: false,
547        };
548        assert_eq!(ParserStrategy::from_manifest(Some(&m)), ParserStrategy::Canonical);
549    }
550
551    #[test]
552    fn spawn_external_missing_parser_command() {
553        use std::os::unix::fs::PermissionsExt;
554
555        let wt = tempfile::tempdir().unwrap();
556        let log_dir = tempfile::tempdir().unwrap();
557        let log_path = log_dir.path().join("worker.log");
558
559        let script = wt.path().join("wrapper.sh");
560        std::fs::write(&script, "#!/bin/sh\nexit 0\n").unwrap();
561        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
562
563        let manifest = Manifest {
564            name: None,
565            contract_version: 1,
566            parser: "external".to_string(),
567            parser_command: None,
568            enforce_worktree_isolation: false,
569        };
570        let wrapper = CustomWrapper {
571            script_path: script,
572            manifest: Some(manifest),
573        };
574
575        let ctx = make_ctx(wt.path(), &log_path);
576        let err = wrapper.spawn(&ctx).unwrap_err();
577        let msg = err.to_string();
578        assert!(msg.contains("parser_command"), "error must mention parser_command: {msg}");
579        assert!(msg.contains("not set"), "error must mention 'not set': {msg}");
580    }
581
582    #[test]
583    fn spawn_external_binary_not_found() {
584        use std::os::unix::fs::PermissionsExt;
585
586        let wt = tempfile::tempdir().unwrap();
587        let log_dir = tempfile::tempdir().unwrap();
588        let log_path = log_dir.path().join("worker.log");
589
590        let script = wt.path().join("wrapper.sh");
591        std::fs::write(&script, "#!/bin/sh\nexit 0\n").unwrap();
592        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
593
594        let manifest = Manifest {
595            name: None,
596            contract_version: 1,
597            parser: "external".to_string(),
598            parser_command: Some("nonexistent-binary-xyzzy-2803".to_string()),
599            enforce_worktree_isolation: false,
600        };
601        let wrapper = CustomWrapper {
602            script_path: script,
603            manifest: Some(manifest),
604        };
605
606        let ctx = make_ctx(wt.path(), &log_path);
607        let err = wrapper.spawn(&ctx).unwrap_err();
608        let msg = err.to_string();
609        assert!(
610            msg.contains("nonexistent-binary-xyzzy-2803"),
611            "error must name the missing binary: {msg}"
612        );
613    }
614
615    #[test]
616    fn spawn_rejects_contract_version_gt_1() {
617        use std::os::unix::fs::PermissionsExt;
618
619        let wt = tempfile::tempdir().unwrap();
620        let log_dir = tempfile::tempdir().unwrap();
621
622        // Create a script (won't be reached due to early bail)
623        let script = wt.path().join("wrapper.sh");
624        std::fs::write(&script, "#!/bin/sh\nexit 0\n").unwrap();
625        std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
626
627        let manifest = Manifest {
628            name: None,
629            contract_version: 2,
630            parser: "canonical".to_string(),
631            parser_command: None,
632            enforce_worktree_isolation: false,
633        };
634
635        let wrapper = CustomWrapper {
636            script_path: script,
637            manifest: Some(manifest),
638        };
639
640        let ctx = make_ctx(wt.path(), &log_dir.path().join("worker.log"));
641        let err = wrapper.spawn(&ctx).unwrap_err();
642        let msg = err.to_string();
643        assert!(msg.contains("upgrade APM"),
644            "error message must mention 'upgrade APM': {msg}");
645    }
646}
apm_core/wrapper/custom.rs

apm_core/wrapper/
custom.rs
