feat(service): expand service layer with new domain operations

- Add IM service modules: audit, channel roles, custom emojis, forum
  tags, integrations, invitations, repo links, slash commands, stages,
  voice, webhooks
- Add PR service modules: review requests, templates
- Add repo service modules: contributors, release assets, git extras
  (archive, branch rename, commit extras, diff/merge, tag, tree)
- Add user service: social (follow/block)
- Add internal auth service
- Update existing service modules with expanded functionality
- Remove deleted IM modules: articles, delivery trace, drafts,
  follows, messages, polls, presence, reactions, threads

service/repo/git/archive.rs

@@ -0,0 +1,42 @@
+use crate::error::AppError;
+use crate::service::RepoService;
+use crate::session::Session;
+
+impl RepoService {
+    pub async fn git_archive(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        format: i32,
+        treeish: &str,
+    ) -> Result<tonic::Streaming<crate::pb::repo::ArchiveChunk>, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.archive;
+        let resp = svc
+            .get_archive(tonic::Request::new(crate::pb::repo::ArchiveRequest {
+                repository: Some(header),
+                treeish: Some(crate::pb::repo::ObjectSelector {
+                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
+                        crate::pb::repo::ObjectName {
+                            revision: treeish.to_string(),
+                        },
+                    )),
+                }),
+                options: Some(crate::pb::repo::ArchiveOptions {
+                    format,
+                    prefix: String::new(),
+                    pathspec: Vec::new(),
+                    compression_level: 0,
+                    include_global_extended_pax_headers: false,
+                }),
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+}

service/repo/git/branch_rename.rs

@@ -0,0 +1,31 @@
+use crate::error::AppError;
+use crate::service::RepoService;
+use crate::session::Session;
+
+impl RepoService {
+    pub async fn git_rename_branch(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        old_name: &str,
+        new_name: &str,
+    ) -> Result<crate::pb::repo::Branch, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_role_at_least(user_uid, &repo, crate::models::common::Role::Admin)
+            .await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.branch;
+        let resp = svc
+            .rename_branch(tonic::Request::new(crate::pb::repo::RenameBranchRequest {
+                repository: Some(header),
+                old_name: old_name.to_string(),
+                new_name: new_name.to_string(),
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+}

service/repo/git/diff_merge_extras.rs

@@ -0,0 +1,213 @@
+use crate::error::AppError;
+use crate::service::RepoService;
+use crate::session::Session;
+use futures_util::StreamExt;
+
+impl RepoService {
+    pub async fn git_get_commit_diff(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        revision: &str,
+    ) -> Result<crate::pb::repo::GetDiffResponse, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.diff;
+        let resp = svc
+            .get_commit_diff(tonic::Request::new(crate::pb::repo::GetCommitDiffRequest {
+                repository: Some(header),
+                commit: Some(crate::pb::repo::ObjectSelector {
+                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
+                        crate::pb::repo::ObjectName {
+                            revision: revision.to_string(),
+                        },
+                    )),
+                }),
+                options: None,
+                pagination: None,
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+
+    pub async fn git_get_patch(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        old_revision: &str,
+        new_revision: &str,
+    ) -> Result<Vec<u8>, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.diff;
+        let mut stream = svc
+            .get_patch(tonic::Request::new(crate::pb::repo::GetPatchRequest {
+                repository: Some(header),
+                base: Some(crate::pb::repo::ObjectSelector {
+                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
+                        crate::pb::repo::ObjectName {
+                            revision: old_revision.to_string(),
+                        },
+                    )),
+                }),
+                head: Some(crate::pb::repo::ObjectSelector {
+                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
+                        crate::pb::repo::ObjectName {
+                            revision: new_revision.to_string(),
+                        },
+                    )),
+                }),
+                options: None,
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?
+            .into_inner();
+
+        let mut data = Vec::new();
+        while let Some(Ok(chunk)) = stream.next().await {
+            data.extend_from_slice(&chunk.data);
+        }
+        Ok(data)
+    }
+
+    pub async fn git_raw_diff(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        old_revision: &str,
+        new_revision: &str,
+    ) -> Result<Vec<u8>, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.diff;
+        let mut stream = svc
+            .raw_diff(tonic::Request::new(crate::pb::repo::RawDiffRequest {
+                repository: Some(header),
+                base: old_revision.to_string(),
+                head: new_revision.to_string(),
+                options: None,
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?
+            .into_inner();
+
+        let mut data = Vec::new();
+        while let Some(Ok(chunk)) = stream.next().await {
+            data.extend_from_slice(&chunk.data);
+        }
+        Ok(data)
+    }
+
+    pub async fn git_find_changed_paths(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        old_revision: &str,
+        new_revision: &str,
+    ) -> Result<crate::pb::repo::FindChangedPathsResponse, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.diff;
+        let resp = svc
+            .find_changed_paths(tonic::Request::new(
+                crate::pb::repo::FindChangedPathsRequest {
+                    repository: Some(header),
+                    base: old_revision.to_string(),
+                    head: new_revision.to_string(),
+                    paths: vec![],
+                },
+            ))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+
+    pub async fn git_stream_blame(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        path: &str,
+        revision: &str,
+    ) -> Result<tonic::Streaming<crate::pb::repo::BlameHunk>, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.blame;
+        let resp = svc
+            .stream_blame(tonic::Request::new(crate::pb::repo::BlameRequest {
+                repository: Some(header),
+                path: path.to_string(),
+                revision: Some(crate::pb::repo::ObjectSelector {
+                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
+                        crate::pb::repo::ObjectName {
+                            revision: revision.to_string(),
+                        },
+                    )),
+                }),
+                range: None,
+                options: None,
+                pagination: None,
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+
+    pub async fn git_resolve_merge_conflicts(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        target_branch: &str,
+        source_revision: &str,
+        message: &str,
+    ) -> Result<crate::pb::repo::MergeResult, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_role_at_least(user_uid, &repo, crate::models::common::Role::Member)
+            .await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.merge;
+        let resp = svc
+            .resolve_merge_conflicts(tonic::Request::new(
+                crate::pb::repo::ResolveMergeConflictsRequest {
+                    repository: Some(header),
+                    target_branch: target_branch.to_string(),
+                    source: Some(crate::pb::repo::ObjectSelector {
+                        selector: Some(crate::pb::repo::object_selector::Selector::Revision(
+                            crate::pb::repo::ObjectName {
+                                revision: source_revision.to_string(),
+                            },
+                        )),
+                    }),
+                    resolutions: vec![],
+                    committer: None,
+                    message: message.to_string(),
+                },
+            ))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+}

service/repo/git/mod.rs

@@ -1,11 +1,20 @@
+pub mod archive;
 pub mod blame;
 pub mod branch;
+pub mod branch_rename;
 pub mod commit;
+pub mod commit_extras;
+pub mod commit_extras2;
 pub mod diff;
+pub mod diff_merge_extras;
 pub mod merge;
+pub mod repo_extras;
 pub mod repository;
+pub mod repository_extras;
 pub mod tag;
+pub mod tag_get;
 pub mod tree;
+pub mod tree_extras;
 
 use crate::error::AppError;
 use crate::models::repos::Repo;

service/repo/git/repository.rs

@@ -120,4 +120,29 @@ impl RepoService {
             .map_err(|e| AppError::InternalServerError(e.to_string()))?;
         Ok(resp.into_inner())
     }
+
+    pub async fn git_set_default_branch(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        branch_name: &str,
+    ) -> Result<(), AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_role_at_least(user_uid, &repo, crate::models::common::Role::Admin)
+            .await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.repository;
+        svc.set_default_branch(tonic::Request::new(
+            crate::pb::repo::SetDefaultBranchRequest {
+                repository: Some(header),
+                name: branch_name.to_string(),
+            },
+        ))
+        .await
+        .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(())
+    }
 }

service/repo/git/repository_extras.rs

@@ -0,0 +1,185 @@
+use crate::error::AppError;
+use crate::service::RepoService;
+use crate::session::Session;
+
+impl RepoService {
+    pub async fn git_get_default_branch(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+    ) -> Result<String, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.repository;
+        let resp = svc
+            .get_default_branch(tonic::Request::new(
+                crate::pb::repo::GetDefaultBranchRequest {
+                    repository: Some(header),
+                },
+            ))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner().name)
+    }
+
+    pub async fn git_get_object_format(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+    ) -> Result<i32, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.repository;
+        let resp = svc
+            .get_object_format(tonic::Request::new(
+                crate::pb::repo::RepositoryObjectFormatRequest {
+                    repository: Some(header),
+                },
+            ))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner().object_format)
+    }
+
+    pub async fn git_objects_size(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        oids: Vec<String>,
+    ) -> Result<crate::pb::repo::ObjectsSizeResponse, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.repository;
+        let resp = svc
+            .objects_size(tonic::Request::new(crate::pb::repo::ObjectsSizeRequest {
+                repository: Some(header),
+                oids,
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+
+    pub async fn git_repository_size(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+    ) -> Result<crate::pb::repo::RepositorySizeResponse, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.repository;
+        let resp = svc
+            .repository_size(tonic::Request::new(
+                crate::pb::repo::RepositorySizeRequest {
+                    repository: Some(header),
+                },
+            ))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+
+    pub async fn git_find_merge_base(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        revisions: Vec<String>,
+    ) -> Result<crate::pb::repo::FindMergeBaseResponse, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.repository;
+        let resp = svc
+            .find_merge_base(tonic::Request::new(crate::pb::repo::FindMergeBaseRequest {
+                repository: Some(header),
+                revisions: revisions
+                    .into_iter()
+                    .map(|s| hex::decode(&s).unwrap_or_default())
+                    .collect(),
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+
+    pub async fn git_list_archive_entries(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        treeish: &str,
+        page_size: u32,
+    ) -> Result<crate::pb::repo::ListArchiveEntriesResponse, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.archive;
+        let resp = svc
+            .list_archive_entries(tonic::Request::new(
+                crate::pb::repo::ListArchiveEntriesRequest {
+                    repository: Some(header),
+                    treeish: Some(crate::pb::repo::ObjectSelector {
+                        selector: Some(crate::pb::repo::object_selector::Selector::Revision(
+                            crate::pb::repo::ObjectName {
+                                revision: treeish.to_string(),
+                            },
+                        )),
+                    }),
+                    pathspec: vec![],
+                    pagination: Some(crate::pb::repo::Pagination {
+                        page_size,
+                        page_token: String::new(),
+                    }),
+                },
+            ))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+
+    pub async fn git_check_objects_exist(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        revisions: Vec<String>,
+    ) -> Result<crate::pb::repo::CheckObjectsExistResponse, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.commit;
+        let resp = svc
+            .check_objects_exist(tonic::Request::new(
+                crate::pb::repo::CheckObjectsExistRequest {
+                    repository: Some(header),
+                    revisions,
+                },
+            ))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+}

service/repo/git/tag_get.rs

@@ -0,0 +1,52 @@
+use crate::error::AppError;
+use crate::service::RepoService;
+use crate::session::Session;
+
+impl RepoService {
+    pub async fn git_get_tag(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        tag_name: &str,
+    ) -> Result<crate::pb::repo::Tag, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.tag;
+        let resp = svc
+            .get_tag(tonic::Request::new(crate::pb::repo::GetTagRequest {
+                repository: Some(header),
+                name: tag_name.to_string(),
+                include_raw: false,
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+
+    pub async fn git_verify_tag(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        tag_name: &str,
+    ) -> Result<crate::pb::repo::VerifiedSignature, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.tag;
+        let resp = svc
+            .verify_tag(tonic::Request::new(crate::pb::repo::VerifyTagRequest {
+                repository: Some(header),
+                name: tag_name.to_string(),
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+}

service/repo/git/tree_extras.rs

@@ -0,0 +1,141 @@
+use crate::error::AppError;
+use crate::service::RepoService;
+use crate::session::Session;
+use futures_util::StreamExt;
+
+impl RepoService {
+    pub async fn git_get_raw_blob(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        revision: &str,
+        path: &str,
+    ) -> Result<Vec<u8>, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.tree;
+        let mut stream = svc
+            .get_raw_blob(tonic::Request::new(crate::pb::repo::GetRawBlobRequest {
+                repository: Some(header),
+                revision: Some(crate::pb::repo::ObjectSelector {
+                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
+                        crate::pb::repo::ObjectName {
+                            revision: revision.to_string(),
+                        },
+                    )),
+                }),
+                path: path.to_string(),
+                oid: None,
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?
+            .into_inner();
+
+        let mut data = Vec::new();
+        while let Some(Ok(chunk)) = stream.next().await {
+            data.extend_from_slice(&chunk.data);
+        }
+        Ok(data)
+    }
+
+    pub async fn git_get_file_metadata(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        revision: &str,
+        path: &str,
+    ) -> Result<crate::pb::repo::FileMetadata, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.tree;
+        let resp = svc
+            .get_file_metadata(tonic::Request::new(
+                crate::pb::repo::GetFileMetadataRequest {
+                    repository: Some(header),
+                    revision: Some(crate::pb::repo::ObjectSelector {
+                        selector: Some(crate::pb::repo::object_selector::Selector::Revision(
+                            crate::pb::repo::ObjectName {
+                                revision: revision.to_string(),
+                            },
+                        )),
+                    }),
+                    path: path.to_string(),
+                },
+            ))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+
+    pub async fn git_find_files(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        revision: &str,
+        pattern: &str,
+    ) -> Result<crate::pb::repo::FindFilesResponse, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.tree;
+        let resp = svc
+            .find_files(tonic::Request::new(crate::pb::repo::FindFilesRequest {
+                repository: Some(header),
+                revision: Some(crate::pb::repo::ObjectSelector {
+                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
+                        crate::pb::repo::ObjectName {
+                            revision: revision.to_string(),
+                        },
+                    )),
+                }),
+                pattern: pattern.to_string(),
+                pathspec: vec![],
+                pagination: None,
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+
+    pub async fn git_get_tree(
+        &self,
+        ctx: &Session,
+        wk_name: &str,
+        repo_name: &str,
+        revision: &str,
+        path: &str,
+    ) -> Result<crate::pb::repo::Tree, AppError> {
+        let user_uid = ctx.user().ok_or(AppError::Unauthorized)?;
+        let repo = self.resolve_repo(wk_name, repo_name).await?;
+        self.ensure_repo_readable(user_uid, &repo).await?;
+        let ws = self.resolve_workspace(wk_name).await?;
+        let header = self.repo_header(&repo, &ws);
+        let mut svc = self.git_client(&repo)?.tree;
+        let resp = svc
+            .get_tree(tonic::Request::new(crate::pb::repo::GetTreeRequest {
+                repository: Some(header),
+                revision: Some(crate::pb::repo::ObjectSelector {
+                    selector: Some(crate::pb::repo::object_selector::Selector::Revision(
+                        crate::pb::repo::ObjectName {
+                            revision: revision.to_string(),
+                        },
+                    )),
+                }),
+                path: path.to_string(),
+            }))
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(resp.into_inner())
+    }
+}