wsb 0.186.4098

Workspace - A tool suite for file operations, version management, and development workflow automation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use crate::prelude::*;
use axum::{
    extract::Query,
    http::StatusCode,
    Json,
};
use std::{cmp::Reverse, fs, path::Path};

const PLANS_DIR: &str = "/Users/bahram/.claude/plans";

#[derive(Debug, Serialize)]
pub struct PlanEntry {
    pub name: String,
    /// Unix timestamp (seconds) of file creation / birth time.
    /// Falls back to last-modified if birth time is unavailable (Linux).
    pub created_at: u64,
}

#[derive(Debug, Serialize)]
pub struct PlansListResponse {
    pub plans: Vec<PlanEntry>,
}

#[derive(Debug, Deserialize)]
pub struct PlanContentQuery {
    pub name: String,
}

#[derive(Debug, Serialize)]
pub struct PlanContentResponse {
    pub name: String,
    pub content: String,
}

pub async fn list_plans() -> Result<Json<PlansListResponse>, (StatusCode, Json<serde_json::Value>)> {
    let mut plans = tokio::task::spawn_blocking(|| {
        let read = fs::read_dir(Path::new(PLANS_DIR)).map_err(|e| {
            (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(serde_json::json!({ "error": format!("failed to read plans directory: {e}") })),
            )
        })?;

        let plans: Vec<PlanEntry> = read
            .filter_map(|entry| {
                let entry = entry.ok()?;
                let path = entry.path();
                if path.extension().and_then(|e| e.to_str()) != Some("md") {
                    return None;
                }
                let name = path.file_name()?.to_str()?.to_owned();
                let meta = fs::metadata(&path).ok()?;
                let created_at = meta
                    .created()
                    .or_else(|_| meta.modified())
                    .ok()
                    .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
                    .map(|d| d.as_secs())
                    .unwrap_or(0);
                Some(PlanEntry { name, created_at })
            })
            .collect();

        Ok(plans)
    })
    .await
    .map_err(|e| {
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({ "error": format!("list_plans task panicked: {e}") })),
        )
    })??;

    plans.sort_by_key(|p| Reverse(p.created_at));

    Ok(Json(PlansListResponse { plans }))
}

pub async fn get_plan_content(
    Query(query): Query<PlanContentQuery>,
) -> Result<Json<PlanContentResponse>, (StatusCode, Json<serde_json::Value>)> {
    // Reject any name that contains path separators or traversal sequences.
    if query.name.contains('/') || query.name.contains("..") {
        return Err((
            StatusCode::BAD_REQUEST,
            Json(serde_json::json!({ "error": "invalid plan name" })),
        ));
    }

    let name = query.name;
    let content = tokio::task::spawn_blocking(move || {
        let path = Path::new(PLANS_DIR).join(&name);
        fs::read_to_string(&path).map_err(|e| {
            (
                StatusCode::NOT_FOUND,
                Json(serde_json::json!({ "error": format!("plan not found: {e}") })),
            )
        })
        .map(|content| (name, content))
    })
    .await
    .map_err(|e| {
        (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(serde_json::json!({ "error": format!("get_plan_content task panicked: {e}") })),
        )
    })??;

    Ok(Json(PlanContentResponse {
        name: content.0,
        content: content.1,
    }))
}