resumeの実装

crates/tui/Cargo.toml

@@ -14,3 +14,4 @@ unicode-width = "0.2.2"
 uuid = "1.23"
 toml = "1.1.2"
 manifest = { version = "0.1.0", path = "../manifest" }
+session-store = { version = "0.1.0", path = "../session-store" }

crates/tui/src/main.rs

@@ -3,6 +3,7 @@ mod block;
 mod cache;
 mod client;
 mod input;
+mod picker;
 mod scroll;
 mod spawn;
 mod tool;
@@ -24,9 +25,11 @@ use crossterm::terminal::{
 use protocol::Method;
 use ratatui::Terminal;
 use ratatui::backend::CrosstermBackend;
+use session_store::SessionId;
 
 use crate::app::App;
 use crate::client::PodClient;
+use crate::picker::PickerOutcome;
 use crate::spawn::{SpawnOutcome, SpawnReady};
 
 fn resolve_socket(pod_name: &str, override_path: Option<PathBuf>) -> PathBuf {
@@ -47,27 +50,101 @@ enum Mode {
         pod_name: String,
         socket_override: Option<PathBuf>,
     },
+    /// `tui -r` / `tui --resume`: open the session picker first, then
+    /// run the same name dialog as Spawn but in resume mode.
+    Resume,
+    /// `tui --session <UUID>`: skip the picker, go straight to the
+    /// resume name dialog with `id` baked in.
+    ResumeWithSession(SessionId),
 }
 
-fn parse_args() -> Mode {
+enum ParseError {
+    Conflict,
+    InvalidSession(String),
+    MissingValue(&'static str),
+}
+
+impl std::fmt::Display for ParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Conflict => write!(f, "--resume and --session are mutually exclusive"),
+            Self::InvalidSession(s) => write!(f, "invalid --session UUID: {s}"),
+            Self::MissingValue(flag) => write!(f, "{flag} requires a value"),
+        }
+    }
+}
+
+fn parse_args() -> Result<Mode, ParseError> {
     let args: Vec<String> = std::env::args().skip(1).collect();
-    if args.is_empty() {
-        return Mode::Spawn;
+    let mut resume = false;
+    let mut session: Option<SessionId> = None;
+    let mut socket_override: Option<PathBuf> = None;
+    let mut positional: Option<String> = None;
+
+    let mut i = 0;
+    while i < args.len() {
+        match args[i].as_str() {
+            "-r" | "--resume" => {
+                resume = true;
+                i += 1;
+            }
+            "--session" => {
+                let raw = args
+                    .get(i + 1)
+                    .ok_or(ParseError::MissingValue("--session"))?;
+                session = Some(
+                    raw.parse::<SessionId>()
+                        .map_err(|_| ParseError::InvalidSession(raw.clone()))?,
+                );
+                i += 2;
+            }
+            "--socket" => {
+                let raw = args
+                    .get(i + 1)
+                    .ok_or(ParseError::MissingValue("--socket"))?;
+                socket_override = Some(PathBuf::from(raw));
+                i += 2;
+            }
+            other if positional.is_none() && !other.starts_with('-') => {
+                positional = Some(other.to_string());
+                i += 1;
+            }
+            _ => {
+                // Unknown flag or extra positional — keep older
+                // behaviour of ignoring unknowns rather than aborting.
+                i += 1;
+            }
+        }
     }
-    let pod_name = args[0].clone();
-    let socket_override = args
-        .windows(2)
-        .find(|w| w[0] == "--socket")
-        .map(|w| PathBuf::from(&w[1]));
-    Mode::Attach {
-        pod_name,
-        socket_override,
+
+    if resume && session.is_some() {
+        return Err(ParseError::Conflict);
     }
+
+    if let Some(id) = session {
+        return Ok(Mode::ResumeWithSession(id));
+    }
+    if resume {
+        return Ok(Mode::Resume);
+    }
+    if let Some(pod_name) = positional {
+        return Ok(Mode::Attach {
+            pod_name,
+            socket_override,
+        });
+    }
+    Ok(Mode::Spawn)
 }
 
 #[tokio::main]
 async fn main() -> ExitCode {
-    let mode = parse_args();
+    let mode = match parse_args() {
+        Ok(m) => m,
+        Err(e) => {
+            eprintln!("tui: {e}");
+            return ExitCode::FAILURE;
+        }
+    };
 
     if let Err(e) = enable_raw_mode() {
         eprintln!("tui: failed to enter raw mode: {e}");
@@ -80,11 +157,13 @@ async fn main() -> ExitCode {
     }
 
     let result = match mode {
-        Mode::Spawn => run_spawn().await,
+        Mode::Spawn => run_spawn(None).await,
         Mode::Attach {
             pod_name,
             socket_override,
         } => run_attach(pod_name, socket_override).await,
+        Mode::Resume => run_resume().await,
+        Mode::ResumeWithSession(id) => run_spawn(Some(id)).await,
     };
 
     // Always restore the terminal first so any pending eprintln below
@@ -120,8 +199,19 @@ async fn run_attach(
     run(&mut terminal, pod_name, &socket_path, false).await
 }
 
-async fn run_spawn() -> Result<(), Box<dyn std::error::Error>> {
-    let ready = match spawn::run().await? {
+async fn run_resume() -> Result<(), Box<dyn std::error::Error>> {
+    // Phase 1: pick a session in its own inline viewport, dropping the
+    // viewport before the name dialog opens so each phase gets fresh
+    // vertical room.
+    let id = match picker::run().await? {
+        PickerOutcome::Picked(id) => id,
+        PickerOutcome::Cancelled => return Ok(()),
+    };
+    run_spawn(Some(id)).await
+}
+
+async fn run_spawn(resume_from: Option<SessionId>) -> Result<(), Box<dyn std::error::Error>> {
+    let ready = match spawn::run(resume_from).await? {
         SpawnOutcome::Ready(r) => r,
         SpawnOutcome::Cancelled => return Ok(()),
     };

crates/tui/src/picker.rs

@@ -0,0 +1,282 @@
+//! Inline-viewport "pick a session to restore" UX.
+//!
+//! Reads the most recent sessions from the configured store, lets the
+//! user pick one with the arrow keys, and returns the chosen
+//! `SessionId`. Closes its inline viewport before returning so the
+//! caller can open a fresh viewport for the name dialog.
+//!
+//! The picker only handles selection. Forking, scope-lock checks, and
+//! actual `pod` launch happen later in the resume flow.
+
+use std::io;
+use std::time::Duration;
+
+use crossterm::event::{self, Event as TermEvent, KeyCode, KeyEventKind, KeyModifiers};
+use ratatui::Terminal;
+use ratatui::backend::CrosstermBackend;
+use ratatui::layout::{Constraint, Layout};
+use ratatui::style::{Color, Modifier, Style};
+use ratatui::text::{Line, Span};
+use ratatui::widgets::Paragraph;
+use ratatui::{Frame, TerminalOptions, Viewport};
+use session_store::{
+    ContentPart, FsStore, HashedEntry, Item, LogEntry, SessionId, Store,
+};
+
+const MAX_ROWS: usize = 10;
+const VIEWPORT_LINES: u16 = MAX_ROWS as u16 + 4;
+
+#[derive(Debug)]
+pub enum PickerError {
+    Io(io::Error),
+    Store(session_store::StoreError),
+    NoSessions,
+}
+
+impl std::fmt::Display for PickerError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Io(e) => write!(f, "io error: {e}"),
+            Self::Store(e) => write!(f, "session store error: {e}"),
+            Self::NoSessions => write!(
+                f,
+                "no sessions found — start a fresh pod with `tui` and try again"
+            ),
+        }
+    }
+}
+
+impl std::error::Error for PickerError {}
+
+impl From<io::Error> for PickerError {
+    fn from(e: io::Error) -> Self {
+        Self::Io(e)
+    }
+}
+
+impl From<session_store::StoreError> for PickerError {
+    fn from(e: session_store::StoreError) -> Self {
+        Self::Store(e)
+    }
+}
+
+pub enum PickerOutcome {
+    Picked(SessionId),
+    Cancelled,
+}
+
+/// One row in the picker view. Rendered from the session log so the
+/// user can recognise their session at a glance without parsing UUIDs.
+struct Row {
+    id: SessionId,
+    /// Last user / assistant snippet, or a `[corrupt]` placeholder.
+    preview: String,
+}
+
+pub async fn run() -> Result<PickerOutcome, PickerError> {
+    let store = open_default_store().await?;
+    let ids = store.list_sessions().await?;
+    if ids.is_empty() {
+        return Err(PickerError::NoSessions);
+    }
+    let mut rows: Vec<Row> = Vec::with_capacity(MAX_ROWS);
+    for id in ids.into_iter().take(MAX_ROWS) {
+        let preview = build_preview(&store, id).await;
+        rows.push(Row { id, preview });
+    }
+
+    let mut selected = 0usize;
+    let mut terminal = make_inline_terminal()?;
+    loop {
+        terminal.draw(|f| draw(f, &rows, selected))?;
+        match poll_event()? {
+            None => continue,
+            Some(Action::Up) => {
+                if selected > 0 {
+                    selected -= 1;
+                }
+            }
+            Some(Action::Down) => {
+                if selected + 1 < rows.len() {
+                    selected += 1;
+                }
+            }
+            Some(Action::Submit) => {
+                drop(terminal);
+                return Ok(PickerOutcome::Picked(rows[selected].id));
+            }
+            Some(Action::Cancel) => {
+                drop(terminal);
+                return Ok(PickerOutcome::Cancelled);
+            }
+        }
+    }
+}
+
+async fn open_default_store() -> Result<FsStore, PickerError> {
+    let dir = manifest::paths::sessions_dir().ok_or_else(|| {
+        PickerError::Io(io::Error::new(
+            io::ErrorKind::NotFound,
+            "could not resolve sessions directory \
+             (set INSOMNIA_HOME, INSOMNIA_DATA_DIR, or HOME)",
+        ))
+    })?;
+    Ok(FsStore::new(&dir).await?)
+}
+
+async fn build_preview(store: &FsStore, id: SessionId) -> String {
+    match store.read_all(id).await {
+        Ok(entries) => last_message_preview(&entries).unwrap_or_else(|| "[empty]".to_string()),
+        Err(_) => "[corrupt]".to_string(),
+    }
+}
+
+/// Walk the log from the tail looking for the most recent user-message
+/// or assistant-message entry, then render its first text fragment in
+/// a single line.
+fn last_message_preview(entries: &[HashedEntry]) -> Option<String> {
+    for hashed in entries.iter().rev() {
+        match &hashed.entry {
+            LogEntry::UserInput { item, .. } => {
+                if let Some(text) = first_text(item) {
+                    return Some(format!("user: {}", trim_one_line(&text, 60)));
+                }
+            }
+            LogEntry::AssistantItems { items, .. } => {
+                if let Some(text) = items.iter().find_map(first_text) {
+                    return Some(format!("assistant: {}", trim_one_line(&text, 60)));
+                }
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
+fn first_text(item: &Item) -> Option<String> {
+    match item {
+        Item::Message { content, .. } => content.iter().find_map(|p| match p {
+            ContentPart::Text { text } => Some(text.clone()),
+            _ => None,
+        }),
+        _ => None,
+    }
+}
+
+fn trim_one_line(s: &str, max_chars: usize) -> String {
+    let collapsed: String = s.chars().map(|c| if c == '\n' { ' ' } else { c }).collect();
+    if collapsed.chars().count() <= max_chars {
+        collapsed
+    } else {
+        let truncated: String = collapsed.chars().take(max_chars - 1).collect();
+        format!("{truncated}…")
+    }
+}
+
+fn make_inline_terminal() -> io::Result<Terminal<CrosstermBackend<io::Stdout>>> {
+    let backend = CrosstermBackend::new(io::stdout());
+    Terminal::with_options(
+        backend,
+        TerminalOptions {
+            viewport: Viewport::Inline(VIEWPORT_LINES),
+        },
+    )
+}
+
+enum Action {
+    Up,
+    Down,
+    Submit,
+    Cancel,
+}
+
+fn poll_event() -> io::Result<Option<Action>> {
+    if !event::poll(Duration::from_millis(100))? {
+        return Ok(None);
+    }
+    match event::read()? {
+        TermEvent::Key(k) if k.kind != KeyEventKind::Release => {
+            let ctrl = k.modifiers.contains(KeyModifiers::CONTROL);
+            Ok(match k.code {
+                KeyCode::Up => Some(Action::Up),
+                KeyCode::Down => Some(Action::Down),
+                KeyCode::Char('k') if !ctrl => Some(Action::Up),
+                KeyCode::Char('j') if !ctrl => Some(Action::Down),
+                KeyCode::Enter => Some(Action::Submit),
+                KeyCode::Esc => Some(Action::Cancel),
+                KeyCode::Char('c') if ctrl => Some(Action::Cancel),
+                _ => None,
+            })
+        }
+        _ => Ok(None),
+    }
+}
+
+fn draw(f: &mut Frame<'_>, rows: &[Row], selected: usize) {
+    let area = f.area();
+    let mut constraints: Vec<Constraint> =
+        Vec::with_capacity(rows.len() + 3);
+    constraints.push(Constraint::Length(1)); // title
+    for _ in rows {
+        constraints.push(Constraint::Length(1));
+    }
+    constraints.push(Constraint::Length(1)); // hint
+    constraints.push(Constraint::Length(1)); // spacer
+    let layout = Layout::vertical(constraints).split(area);
+
+    f.render_widget(
+        Paragraph::new(Line::from(vec![Span::styled(
+            "resume pod   pick a session",
+            Style::default().add_modifier(Modifier::BOLD),
+        )])),
+        layout[0],
+    );
+
+    for (i, row) in rows.iter().enumerate() {
+        f.render_widget(
+            Paragraph::new(row_line(row, i == selected)),
+            layout[i + 1],
+        );
+    }
+
+    f.render_widget(
+        Paragraph::new(Line::from(vec![
+            Span::raw("  "),
+            Span::styled("[↑/↓]", Style::default().fg(Color::DarkGray)),
+            Span::raw(" select   "),
+            Span::styled("[enter]", Style::default().fg(Color::Green)),
+            Span::raw(" pick   "),
+            Span::styled("[esc]", Style::default().fg(Color::Yellow)),
+            Span::raw(" cancel"),
+        ])),
+        layout[rows.len() + 1],
+    );
+}
+
+fn row_line(row: &Row, selected: bool) -> Line<'_> {
+    let marker = if selected { "▶ " } else { "  " };
+    let id_style = if selected {
+        Style::default()
+            .fg(Color::Cyan)
+            .add_modifier(Modifier::BOLD)
+    } else {
+        Style::default().fg(Color::Cyan)
+    };
+    let preview_style = if selected {
+        Style::default().fg(Color::White)
+    } else {
+        Style::default().fg(Color::DarkGray)
+    };
+    Line::from(vec![
+        Span::raw(marker),
+        Span::styled(short_session(row.id), id_style),
+        Span::raw("  "),
+        Span::styled(row.preview.clone(), preview_style),
+    ])
+}
+
+fn short_session(id: SessionId) -> String {
+    let s = id.to_string();
+    s.chars().take(8).collect()
+}
+

crates/tui/src/spawn.rs

@@ -20,6 +20,7 @@ use std::time::Duration;
 use crossterm::event::{self, Event as TermEvent, KeyCode, KeyEventKind, KeyModifiers};
 use manifest::{PodManifestConfig, find_project_manifest_from, load_layer, user_manifest_path};
 use ratatui::Terminal;
+use session_store::SessionId;
 use ratatui::backend::CrosstermBackend;
 use ratatui::layout::{Constraint, Layout};
 use ratatui::style::{Color, Modifier, Style};
@@ -85,7 +86,10 @@ impl From<io::Error> for SpawnError {
 
 type InlineTerminal = Terminal<CrosstermBackend<io::Stdout>>;
 
-pub async fn run() -> Result<SpawnOutcome, SpawnError> {
+/// Source session for a resume run. `None` = fresh spawn (current
+/// behaviour); `Some(id)` swaps the dialog into "Resume Pod" mode and
+/// passes `--session <id>` to the spawned `pod` child.
+pub async fn run(resume_from: Option<SessionId>) -> Result<SpawnOutcome, SpawnError> {
     let cwd = std::env::current_dir().map_err(SpawnError::Io)?;
 
     // Run the same merge pod itself uses, then read what's missing
@@ -135,6 +139,7 @@ pub async fn run() -> Result<SpawnOutcome, SpawnError> {
         name: default_name,
         message: None,
         editing: true,
+        resume_from,
     };
 
     let mut terminal = make_inline_terminal()?;
@@ -266,16 +271,19 @@ async fn wait_for_ready(
     let pod_bin = resolve_pod_command();
     let cwd = std::env::current_dir().map_err(SpawnError::Io)?;
 
-    let mut child = Command::new(&pod_bin)
+    let mut command = Command::new(&pod_bin);
+    command
         .arg("--overlay")
         .arg(overlay_toml)
         .current_dir(&cwd)
         .stdin(Stdio::null())
         .stdout(Stdio::null())
         .stderr(Stdio::piped())
-        .kill_on_drop(true)
-        .spawn()
-        .map_err(SpawnError::PodLaunchFailed)?;
+        .kill_on_drop(true);
+    if let Some(id) = form.resume_from {
+        command.arg("--session").arg(id.to_string());
+    }
+    let mut child = command.spawn().map_err(SpawnError::PodLaunchFailed)?;
 
     let stderr = child
         .stderr
@@ -437,6 +445,11 @@ struct Form {
     /// cursor stays out so it does not collide with the shell prompt
     /// after the inline terminal is dropped.
     editing: bool,
+    /// `Some(id)` flips the dialog into "Resume Pod" mode: the title
+    /// switches, the source session is shown to the user, and the
+    /// child pod is launched with `--session <id>` so it forks and
+    /// restores `id`.
+    resume_from: Option<SessionId>,
 }
 
 impl Form {
@@ -500,8 +513,12 @@ fn draw_form(f: &mut Frame<'_>, form: &Form) {
     ])
     .split(area);
 
+    let title_text = match form.resume_from {
+        Some(id) => format!("resume pod   session: {}", short_session(id)),
+        None => "spawn pod".to_string(),
+    };
     let title = Paragraph::new(Line::from(vec![Span::styled(
-        "spawn pod",
+        title_text,
         Style::default().add_modifier(Modifier::BOLD),
     )]));
     f.render_widget(title, layout[0]);
@@ -523,6 +540,13 @@ fn draw_form(f: &mut Frame<'_>, form: &Form) {
     }
 }
 
+/// First 8 hex digits of a UUID — short enough to skim, long enough
+/// to disambiguate inside a 10-row picker.
+pub(crate) fn short_session(id: SessionId) -> String {
+    let s = id.to_string();
+    s.chars().take(8).collect()
+}
+
 fn name_line(form: &Form) -> Line<'_> {
     Line::from(vec![
         Span::raw("  "),
@@ -600,6 +624,7 @@ mod tests {
             name_cursor: name.chars().count(),
             message: None,
             editing: true,
+            resume_from: None,
         }
     }