Method execute

src/commands/shell.rs:22–87

(&self, ctx: &AppContext)

#[async_trait]
impl Command for ShellCommand {
    async fn execute(&self, ctx: &AppContext) -> Result<(), Box<dyn Error>> {
        let args = &self.task_args;
        let name = args.resolved_name();

        let prompt = args.resolve_prompt()?;
        let repo_root = args.resolve_repo_root()?;

        let task = args
            .configure_builder(repo_root, name.clone(), args.agent.clone(), prompt)
            .with_interactive(true) // Shell sessions are always interactive
            .build(ctx)
            .await?;

        println!(
            "Shell {} ({}, {}){}",
            task.id,
            task.stack,
            task.agent,
            args.branch_suffix()
        );

        // Update terminal title for the shell session
        ctx.terminal_operations()
            .set_title(&format!("TSK Shell: {name}"));

        // Execute the task
        let docker_client: Arc<dyn crate::context::docker_client::DockerClient> = Arc::new(
            DefaultDockerClient::new(&ctx.tsk_config().container_engine)
                .map_err(|e| -> Box<dyn Error> { e.into() })?,
        );
        let docker_manager = DockerManager::new(ctx, docker_client.clone(), None);
        let task_runner = TaskRunner::new(ctx, docker_manager, None);

        // Set up signal handler for cancellation.
        // During the active interactive session, Ctrl+C is forwarded to the container
        // via raw mode stdin, so this handler primarily catches SIGTERM signals
        // and Ctrl+C during setup/teardown windows.
        let storage = ctx.task_storage();
        let task_id = task.id.clone();
        let container_name = format!("tsk-interactive-{}", task.id);
        let cancel_client = docker_client.clone();
        let cancel_storage = storage.clone();

        tokio::spawn(async move {
            let mut sigterm =
                signal(SignalKind::terminate()).expect("Failed to listen for SIGTERM");
            tokio::select! {
                _ = tokio::signal::ctrl_c() => {},
                _ = sigterm.recv() => {},
            }
            let _ = cancel_storage.mark_cancelled(&task_id).await;
            let _ = cancel_client.kill_container(&container_name).await;
        });

        let result = task_runner
            .store_and_run(&task)
            .await
            .map_err(|e| e.message);