Skip to content

Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors

Rust

feat(admin): rename-workspace endpoint (column-only)

Djalma Júnior92ed027361d9
diff --git a/crates/ai-memory-mcp/src/admin.rs b/crates/ai-memory-mcp/src/admin.rs
index ca15b484..2bd6e67b 100644
--- a/crates/ai-memory-mcp/src/admin.rs
+++ b/crates/ai-memory-mcp/src/admin.rs
@@ -516,6 +516,7 @@ pub fn admin_router(state: AdminState) -> Router {
.route("/admin/rename-project", post(handle_rename_project))
.route("/admin/move-project", post(handle_move_project))
.route("/admin/delete-workspace", post(handle_delete_workspace))
+ .route("/admin/rename-workspace", post(handle_rename_workspace))
.route("/admin/write-page", post(handle_write_page))
.route("/admin/delete-page", post(handle_delete_page));
let users = Router::new()
@@ -2954,6 +2955,75 @@ async fn handle_purge_project(
// rename-project
// ---------------------------------------------------------------------
+/// JSON request body for `POST /admin/rename-workspace`.
+#[derive(Deserialize)]
+struct RenameWorkspaceRequest {
+ /// Current workspace name (must exist).
+ from: String,
+ /// New workspace name. Must be non-empty, no slashes, and not already used.
+ to: String,
+}
+
+/// Wire-format summary returned by `POST /admin/rename-workspace`.
+#[derive(Debug, Serialize)]
+pub struct RenameWorkspaceResult {
+ /// Previous workspace name.
+ pub from: String,
+ /// New workspace name.
+ pub to: String,
+ /// Post-rename mirror checkpoint, if one was taken.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub checkpoint: Option<String>,
+}
+
+/// `POST /admin/rename-workspace` — rename a workspace (column-only; the
+/// on-disk dir is UUID-keyed, so nothing moves). 404 unknown, 422 taken/invalid.
+async fn handle_rename_workspace(
+ State(state): State<Arc<AdminState>>,
+ Json(req): Json<RenameWorkspaceRequest>,
+) -> impl IntoResponse {
+ let ws_id = match state.reader.find_workspace(req.from.clone()).await {
+ Ok(Some(id)) => id,
+ Ok(None) => {
+ return (
+ StatusCode::NOT_FOUND,
+ Json(serde_json::json!({
+ "error": format!("workspace '{}' not found", req.from)
+ })),
+ );
+ }
+ Err(e) => {
+ return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ Json(serde_json::json!({ "error": e.to_string() })),
+ );
+ }
+ };
+ if let Err(e) = state.writer.rename_workspace(ws_id, req.to.clone()).await {
+ let status = match &e {
+ StoreError::WorkspaceNameTaken(_) | StoreError::InvalidWorkspaceName(_) => {
+ StatusCode::UNPROCESSABLE_ENTITY
+ }
+ StoreError::NotFound(_) => StatusCode::NOT_FOUND,
+ _ => StatusCode::INTERNAL_SERVER_ERROR,
+ };
+ return (status, Json(serde_json::json!({ "error": e.to_string() })));
+ }
+ let checkpoint = checkpoint_or_warn(
+ &state.wiki,
+ format!("rename-workspace {} -> {}", req.from, req.to),
+ );
+ let result = RenameWorkspaceResult {
+ from: req.from.clone(),
+ to: req.to.clone(),
+ checkpoint,
+ };
+ (
+ StatusCode::OK,
+ Json(serde_json::to_value(&result).unwrap_or(serde_json::Value::Null)),
+ )
+}
+
/// JSON request body for `POST /admin/delete-workspace`.
#[derive(Deserialize)]
struct DeleteWorkspaceRequest {
diff --git a/crates/ai-memory-mcp/tests/admin_move.rs b/crates/ai-memory-mcp/tests/admin_move.rs
index a979c312..4640b3ca 100644
--- a/crates/ai-memory-mcp/tests/admin_move.rs
+++ b/crates/ai-memory-mcp/tests/admin_move.rs
@@ -1633,3 +1633,66 @@ async fn delete_workspace_unknown_is_404() {
.await;
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
}
+
+#[tokio::test]
+async fn rename_workspace_ok_collision_and_unknown() {
+ // OK: renames in place; old name no longer resolves, new one does.
+ {
+ let tmp = TempDir::new().unwrap();
+ let (state, store) = make_state(&tmp).await;
+ seed_page(&store, &state.wiki, "old", "proj", "notes/a.md", "b").await;
+ let resp = post(
+ state,
+ "/admin/rename-workspace",
+ json!({"from":"old","to":"new"}),
+ )
+ .await;
+ assert_eq!(resp.status(), StatusCode::OK);
+ assert!(
+ store
+ .reader
+ .find_workspace("new".into())
+ .await
+ .unwrap()
+ .is_some()
+ );
+ assert!(
+ store
+ .reader
+ .find_workspace("old".into())
+ .await
+ .unwrap()
+ .is_none()
+ );
+ }
+ // 422: destination name already taken.
+ {
+ let tmp = TempDir::new().unwrap();
+ let (state, store) = make_state(&tmp).await;
+ seed_page(&store, &state.wiki, "old", "proj", "notes/a.md", "b").await;
+ store
+ .writer
+ .get_or_create_workspace("occupied")
+ .await
+ .unwrap();
+ let resp = post(
+ state,
+ "/admin/rename-workspace",
+ json!({"from":"old","to":"occupied"}),
+ )
+ .await;
+ assert_eq!(resp.status(), StatusCode::UNPROCESSABLE_ENTITY);
+ }
+ // 404: unknown source workspace.
+ {
+ let tmp = TempDir::new().unwrap();
+ let (state, _store) = make_state(&tmp).await;
+ let resp = post(
+ state,
+ "/admin/rename-workspace",
+ json!({"from":"ghost","to":"x"}),
+ )
+ .await;
+ assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+ }
+}
diff --git a/crates/ai-memory-store/src/error.rs b/crates/ai-memory-store/src/error.rs
index c991d80d..4cf8ff86 100644
--- a/crates/ai-memory-store/src/error.rs
+++ b/crates/ai-memory-store/src/error.rs
@@ -60,6 +60,15 @@ pub enum StoreError {
#[error("workspace still has {0} project(s); pass force to delete anyway")]
WorkspaceNotEmpty(u64),
+ /// A workspace rename was rejected because the destination name is already
+ /// in use by another workspace (`workspaces.name` is UNIQUE).
+ #[error("workspace name '{0}' is already taken")]
+ WorkspaceNameTaken(String),
+
+ /// The supplied workspace name failed validation (empty, slash, etc.).
+ #[error("invalid workspace name: {0}")]
+ InvalidWorkspaceName(String),
+
/// A UNIQUE constraint was violated by an insert (e.g. duplicate
/// `users.username` / `users.email`). The string carries a
/// human-readable explanation the CLI / admin endpoint surfaces
diff --git a/crates/ai-memory-store/src/ops.rs b/crates/ai-memory-store/src/ops.rs
index 35e6b942..05ef4e72 100644
--- a/crates/ai-memory-store/src/ops.rs
+++ b/crates/ai-memory-store/src/ops.rs
@@ -1398,6 +1398,48 @@ pub fn delete_workspace(
})
}
+/// Rename a workspace: a `workspaces.name` UPDATE only — the on-disk dir is
+/// keyed by UUID, so nothing moves. Mirrors [`rename_project`].
+///
+/// # Errors
+/// [`StoreError::InvalidWorkspaceName`] on an empty / `/`-containing name;
+/// [`StoreError::WorkspaceNameTaken`] on a `UNIQUE(name)` collision;
+/// [`StoreError::NotFound`] when the workspace vanished (race with delete).
+pub fn rename_workspace(
+ conn: &mut Connection,
+ workspace_id: &WorkspaceId,
+ new_name: &str,
+) -> StoreResult<()> {
+ let trimmed = new_name.trim();
+ if trimmed.is_empty() {
+ return Err(StoreError::InvalidWorkspaceName(
+ "workspace name must not be empty or all whitespace".into(),
+ ));
+ }
+ if trimmed.contains('/') {
+ return Err(StoreError::InvalidWorkspaceName(
+ "workspace name must not contain '/'".into(),
+ ));
+ }
+ let rows = conn.execute(
+ "UPDATE workspaces SET name = ?1 WHERE id = ?2",
+ params![trimmed, workspace_id.as_bytes()],
+ );
+ match rows {
+ Ok(0) => Err(StoreError::NotFound(format!(
+ "workspace id {workspace_id} no longer exists (race with delete)"
+ ))),
+ Ok(_) => Ok(()),
+ Err(rusqlite::Error::SqliteFailure(err, _))
+ if err.extended_code == rusqlite::ffi::SQLITE_CONSTRAINT_UNIQUE
+ || err.code == rusqlite::ErrorCode::ConstraintViolation =>
+ {
+ Err(StoreError::WorkspaceNameTaken(trimmed.to_string()))
+ }
+ Err(e) => Err(StoreError::Sqlite(e)),
+ }
+}
+
/// Summary returned by [`move_project_workspace`] and exposed via
/// [`crate::writer::WriterHandle::move_project_workspace`].
#[derive(Debug, Default, Clone)]
@@ -1822,6 +1864,31 @@ mod tests {
assert_eq!(summary.pages_deleted, 0);
}
+ #[test]
+ fn rename_workspace_updates_name_and_rejects_collision() {
+ let (_tmp, mut conn, ws, _proj) = fresh_db();
+ get_or_create_workspace(&mut conn, "taken").unwrap();
+
+ rename_workspace(&mut conn, &ws, "renamed").unwrap();
+ let name: String = conn
+ .query_row(
+ "SELECT name FROM workspaces WHERE id = ?1",
+ rusqlite::params![ws.as_bytes()],
+ |r| r.get(0),
+ )
+ .unwrap();
+ assert_eq!(name, "renamed", "name column updated in place");
+
+ assert!(matches!(
+ rename_workspace(&mut conn, &ws, "taken").unwrap_err(),
+ StoreError::WorkspaceNameTaken(_)
+ ));
+ assert!(matches!(
+ rename_workspace(&mut conn, &ws, " ").unwrap_err(),
+ StoreError::InvalidWorkspaceName(_)
+ ));
+ }
+
fn fresh_db() -> (
TempDir,
Connection,
diff --git a/crates/ai-memory-store/src/writer.rs b/crates/ai-memory-store/src/writer.rs
index 88f6c991..37eb0139 100644
--- a/crates/ai-memory-store/src/writer.rs
+++ b/crates/ai-memory-store/src/writer.rs
@@ -163,6 +163,12 @@ pub(crate) enum WriteCmd {
force: bool,
reply: oneshot::Sender<StoreResult<DeleteWorkspaceSummary>>,
},
+ /// Rename a workspace's `name` column (UUID-keyed dir doesn't move).
+ RenameWorkspace {
+ workspace_id: WorkspaceId,
+ new_name: String,
+ reply: oneshot::Sender<StoreResult<()>>,
+ },
/// Re-stamp a project's `workspace_id` across every domain table in one
/// transaction, keeping the same `project_id` (a lossless cross-workspace
/// "true move"). The caller renames the on-disk dir and ensures the
@@ -655,6 +661,26 @@ impl WriterHandle {
rx.await.map_err(|_| StoreError::WriterClosed)?
}
+ /// Rename a workspace (column-only; the on-disk dir is UUID-keyed).
+ ///
+ /// # Errors
+ /// [`StoreError::WorkspaceNameTaken`] / [`StoreError::InvalidWorkspaceName`]
+ /// / [`StoreError::NotFound`] / [`StoreError::WriterClosed`].
+ pub async fn rename_workspace(
+ &self,
+ workspace_id: WorkspaceId,
+ new_name: impl Into<String>,
+ ) -> StoreResult<()> {
+ let (tx, rx) = oneshot::channel();
+ self.send(WriteCmd::RenameWorkspace {
+ workspace_id,
+ new_name: new_name.into(),
+ reply: tx,
+ })
+ .await?;
+ rx.await.map_err(|_| StoreError::WriterClosed)?
+ }
+
/// Re-stamp a project's `workspace_id` to `to_workspace` across every
/// domain table in one transaction, keeping the same `project_id`. This is
/// the lossless cross-workspace move: pages, sessions, observations and
@@ -1201,6 +1227,14 @@ fn worker_loop(mut conn: Connection, mut rx: mpsc::Receiver<WriteCmd>) {
let result = ops::delete_workspace(&mut conn, &workspace_id, force);
send_or_warn(reply, result, "delete_workspace");
}
+ WriteCmd::RenameWorkspace {
+ workspace_id,
+ new_name,
+ reply,
+ } => {
+ let result = ops::rename_workspace(&mut conn, &workspace_id, &new_name);
+ send_or_warn(reply, result, "rename_workspace");
+ }
WriteCmd::MoveProjectWorkspace {
project_id,
from_workspace,