text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>plit(input);
if parts.is_empty() {
Err(CommandBuildError::EmptyCommand)
} else {
Ok(parts)
}
}
#[cfg(not(windows))]
{
shlex::split(input).ok_or_else(|| CommandBuildError::InvalidBase(input.to_string()))
}
}
pub fn apply_overrides(
... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{collections::HashMap, path::PathBuf};
use git::GitService;
use tokio::process::Command;
use crate::command::CmdOverrides;
/// Repository context for executor operations
#[derive(Debug, Clone, Default)]
pub struct RepoContext {
pub workspace_root: PathBuf,
/// Names of repositories in ... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::path::Path<|fim_suffix|>eKey {
pub fn new(path: Option<&PathBuf>, cmd_key: String, base_executor: BaseCodingAgent) -> Self {
Self {
path: path.cloned(),
cmd_key,
base_executor,
}
}
}
<|fim_middle|>Buf;
use serde::{Deserialize, Serialize... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::sync::Arc;
use agent_client_protocol::{self as acp};
use async_trait::async_trait;
use tokio::sync::{Mutex, mpsc};
use tokio_util::sync::CancellationToken;
use tracing::{debug, warn};
use workspace_utils::approvals::ApprovalStatus;
use crate::{
approvals::{ExecutorApprovalError, ExecutorApp... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>utdown_rx.clone();
tokio::spawn(async move {
let mut stdout_stream = ReaderStream::new(orig_stdout);
while let Some(res) = stdout_stream.next().await {
if *stdout_shutdown_rx.borrow() {
break;
}
match res {... | fim | BloopAI/vibe-kanban | rust |
pub mod client;
pub mod harness;
pub mod normalize_logs;
pub mod session;
use std::{fmt::Display, str::FromStr};
pub use client::AcpClient;
pub use harness::AcpAgentHarness;
pub use normalize_logs::*;
use serde::{Deserialize, Serialize};
pub use session::SessionManager;
use workspace_utils::approvals::ApprovalStatus;... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>title.clone(),
action_type: action,
status: convert_tool_status(&tool_data.status),
},
content: get_tool_content(tool_data),
metadata: serde_json::to_value(ToolCallMetadata {
tool_call_id: tool_data... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|> return serde_json::to_string(&serde_json::json!({ key: text.text })).ok();
}
}
_ => {}
}
serde_json::to_string(&event).ok()
}
/// Read the raw JSONL content of a session
pub fn read_session_raw(&self, session_id: &st... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{path::Path, process::Stdio, sync::Arc};
use async_trait::async_trait;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use tokio::{io::AsyncWriteExt, process::Command};
use ts_rs::TS;
use workspace_utils::{command_ext::GroupSpawnNoWindowExt, msg_store::MsgStore};
use crate::{
... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>n/api/agent-sdk/permissions#permission-flow-diagram
Ok(serde_json::json!({
"hookSpecificOutput": {
"hookEventName": "PreToolUse",
"permissionDecision": "ask",
"permissionDecision... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>ns, tool_use_id)
.await
{
Ok(result) => {
if let Err(e) = self
.send_hook_response(request_id, serde_json::to_value(result).unwrap())
.await
{
... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>lease notes".to_string()),
},
]
}).clone()
}
async fn build_slash_commands_discovery_command_builder(
&self,
) -> Result<CommandBuilder, CommandBuildError> {
let mut builder =
CommandBuilder::new(base_command(self.claude_code_rou... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>static str {
match self {
Self::Default => "default",
Self::AcceptEdits => "acceptEdits",
Self::Plan => "plan",
Self::BypassPermissions => "bypassPermissions",
}
}
}
impl std::fmt::Display for PermissionMode {
fn fmt(&self, f: &mut s... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>ecutorError> {
self.log_writer.log_raw(raw).await?;
Ok(())
}
}
async fn send_server_response<T>(
peer: &JsonRpcPeer,
request_id: RequestId,
response: T,
) -> Result<(), ExecutorError>
where
T: Serialize,
{
let payload = JSONRPCResponse {
id: request_id,
... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|> .await;
}
Ok(JSONRPCMessage::Error(error)) => {
let request_id = error.id.clone();
if callbacks
... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::sync::Arc;
use codex_app_server_protocol::{ReviewTarget, ThreadStartParams};
use super::{client::AppServerClient, fork_params_from};
use crate::executors::ExecutorError;
pub async fn launch_codex_review(
thread_start_params: ThreadStartParams,
resume_session: Option<String>,
review... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::path::{Path, PathBuf};
use codex_app_server_protocol::{ConfigEdit, JSONRPCNotification, MergeStrategy};
use codex_protocol::{
config_types::ServiceTier,
protocol::{AgentMessageEvent, ErrorEvent, EventMsg},
};
use serde_json::json;
use super::{
Codex,
client::{AppServerClient, Lo... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>pub mod client;
pub mod jsonrpc;
pub mod normalize_logs;
pub mod review;
pub mod slash_commands;
use std::{
collections::HashMap,
env,
path::{Path, PathBuf},
str::FromStr,
sync::Arc,
};
/// Returns the Codex home directory.
///
/// Checks the `CODEX_HOME` environment variable first, t... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>t-4", "Claude Sonnet 4"),
]
.into_iter()
.map(|(id, name)| ModelInfo {
id: id.to_string(),
name: name.to_string(),
provider_id: None,
reasoning_options: vec![],
}... | fim | BloopAI/vibe-kanban | rust |
use std::{collections::HashSet, env, io::ErrorKind, path::Path};
use sha2::{Digest, Sha256};
use tokio::fs;
use tracing::warn;
use super::CursorAgent;
use crate::executors::{CodingAgent, ExecutorError, StandardCodingAgentExecutor};
pub(super) async fn ensure_mcp_server_trust(cursor: &CursorAgent, current_dir: &Path)... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use core::str;
use std::{collections::HashMap, path::Path, process::Stdio, sync::Arc, time::Duration};
use async_trait::async_trait;
use futures::StreamExt;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use tokio::{io::AsyncWriteExt, process::Command};
use ts_rs::TS;
use workspace_utils:... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{
collections::{HashMap, VecDeque},
path::Path,
sync::Arc,
};
use futures::{StreamExt, future::ready};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use workspace_utils::{
diff::normalize_unified_diff, msg_store::MsgStore, path::make_path_relative,
};
use crate::lo... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{path::Path, process::Stdio, sync::Arc};
use async_trait::async_trait;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use strum_macros<|fim_suffix|>"minimax-m2.5", "MiniMax M2.5"),
("glm-4.7", "GLM-4.7"),
("claude-opus-4-5-20251101", "Claud... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{path::Path, sync::Arc};
use async_trait::async_trait;
use derivative::Derivative;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use ts_rs::TS;
use workspace_utils::msg_store::MsgStore;
pub use super::acp::AcpAgentHarness;
use crate::{
approvals::ExecutorApprovalService,
... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|> child,
exit_signal: None,
cancel: None,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, TS, JsonSchema)]
#[serde(transparent)]
#[schemars(
title = "Append Prompt",
description = "Extra text appended to the prompt",
extend("format" ... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>sistant {
return;
}
let Some(ref tokens) = message.tokens else {
return;
};
let total_tokens =
tokens.input + tokens.output + tokens.cache.as_ref().map(|c| c.read).unwrap_or(0);
if total_tokens == 0 {
return;
}
let provider_id = message.provi... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{collections::HashMap, path::Path, sync::Arc};
type MessageId = String;
type PartId = String;
use futures::StreamExt;
use serde::Deserialize;
use serde_json::Value;
use workspace_utils::{
approvals::{ApprovalStatus, QuestionStatus},
msg_store::MsgStore,
path::make_path_relative,
};
... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>ed) else {
let _ = ctx
.log_writer
.log_error(format!(
"OpenCode event stream delivered non-JSON event payload: {trimmed}"
))
.await;
continue;
};
let Some(event_type) = data.get("t... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>equires_existing_session() && config.resume_session_id.is_none() {
log_writer
.log_slash_command_result(format_no_session())
.await?;
log_writer.log_event(&OpencodeExecutorEvent::Done).await?;
return Ok(());
}
let session_id = match config.resume_se... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::collections::HashMap;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use workspace_utils::approvals::{ApprovalStatus, QuestionStatus};
/// JSON log events emitted by the OpenCode SDK executor.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{cmp::Ordering, path::Path, sync::Arc, time::Duration};
use async_trait::async_trait;
use command_group::AsyncGroupChild;
use convert_case::{Case, Casing};
use deriva<|fim_suffix|>))
})?;
let stdout = create_stdout_pipe_writer(&mut child)?;
let log_writer = LogWriter::ne... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|> );
}
}
#[test]
fn test_escape_special_characters() {
let logs = generate_mock_logs("test with \"quotes\" and\nnewlines");
// The final assistant message (index 8) should contain the prompt
let final_log = &logs[8];
let parsed: ClaudeJson = ser... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{path::Path, sync::Arc};
use async_trait::async_trait;
use derivative::Derivative;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use ts_rs::TS;
use workspace_utils::msg_store::MsgStore;
use crate::{
approvals::ExecutorApprovalService,
<|fim_suffix|> harness =... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>arm the cache.
pub async fn preload_global_executor_options_cache() {
let configs = ExecutorConfigs::get_cached();
let executors: Vec<BaseCodingAgent> = configs.executors.keys().copied().collect();
for base_agent in executors {
spawn_global_cache_refresh_for_agent_with_configs(base_ag... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|> mcp_config;
pub mod model_selector;
pub mod profile;
pub mod stdout_dup;
<|fim_prefix|>pub mod actions;
pub mod approvals;
pub mod command<|fim_middle|>;
pub mod env;
pub mod executor_discovery;
pub mod executors;
pub mod logs;
pub mod<|endoftext|> | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use serde::{Deserialize, Serialize};
use ts_rs::TS;
use workspace_utils::approvals::{ApprovalStatus, QuestionStatus};
use crate::logs::utils::shell_command_parsing::CommandCategory;
pub mod plain_text_processor;
pub mod stderr_processor;
pub mod utils;
#[derive(Debug, Clone, Serialize, Deserialize, TS)... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>ate_patch(lines));
// Move to next entry after size split
self.current_entry_index = None;
}
}
// Send partial udpdates
if !self.buffer.is_empty() {
// Stream updates without consuming buffer
patches.push(self.cre... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>::EntryIndexProvider;
/// Standard stderr log normalizer that uses PlainTextLogProcessor to stream error logs.
///
/// Splits stderr output into discrete entries based on a latency threshold (2s) to group
/// related lines into a single error entry. Each entry is normalized as an `ErrorMessage`
/// and e... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>//! Entry Index Provider for thread-safe monotonic indexing
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
use json_patch::PatchOperation;
use workspace_utils::{log_msg::LogMsg, msg_store::MsgStore};
/// Thread-safe provider for monotonically increasing entry indexes
#[derive(Debug, ... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>//! Utility modules for executor<|fim_suffix|>mmand_parsing;
<|fim_middle|> framework
pub mod entry_index;
pub mod patch;
pub use entry_index::EntryIndexProvider;
pub use patch::ConversationPatch;
pub mod shell_co<|endoftext|> | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>
.unwrap()
}
}
/// Extract the entry index and `NormalizedEntry` from a JsonPatch if it contains one
pub fn extract_normalized_entry_from_patch(patch: &Patch) -> Option<(usize, NormalizedEntry)> {
let value = to_value(patch).ok()?;
let ops = value.as_array()?;
ops.iter().rev().fin... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>;
let first_word = &trimmed[..first_word_end];
let cmd_name = first_word.rsplit('/').next().unwrap_or(first_word);
// Check for shell -c "command"
if matches!(cmd_name, "sh" | "bash" | "zsh") {
let after_cmd = &trimmed[first_word_end..];
if let Som... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>ode(_) => Opencode,
CodingAgent::Copilot(..) => Copilot,
#[cfg(feature = "qa-mode")]
CodingAgent::QaMock(_) => Passthrough, // QA mock doesn't need MCP
};
let canonical = PRECONFIGURED_MCP_SERVERS.clone();
apply_adapter(adapter, canonical)
}... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use convert_case::{Case, Casing};
use serde::{Deserialize, Serialize};
use ts_rs::TS;
/// Provider information
#[derive(Debug, Clone, Serialize, Deserialize, TS)]
pub struct ModelProvider {
/// Provider identifier
pub id: String,
/// Display name
pub name: String,
}
/// Basic model infor... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{
collections::HashMap,
fs,
str::FromStr,
sync::{LazyLock, RwLock},
};
use convert_case::{Case, Casing};
use serde::{Deserialize, Deserializer, Serialize, de::Error as DeError};
use thiserror::Error;
use ts_rs::TS;
use crate::{
executors::{AvailabilityInfo, BaseCodingAgent, ... | fim | BloopAI/vibe-kanban | rust |
//! Cross-platform stdout duplication utility for child processes
//!
//! Provides a single function to duplicate a child process's stdout stream.
//! Supports Unix and Windows platforms.
#[cfg(unix)]
use std::os::unix::io::{FromRawFd, IntoRawFd, OwnedFd};
#[cfg(windows)]
use std::os::windows::io::{FromRawHandle, Into... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>(), GitCliError> {
if !self.is_cherry_pick_in_progress(worktree_path)? {
return Ok(());
}
self.git(worktree_path, ["cherry-pick", "--abort"])
.map(|_| ())
}
pub fn abort_revert(&self, worktree_path: &Path) -> Result<(), GitCliError> {
if !se... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>anchType::Remote) {
Ok(_) => Ok(true),
Err(_) => Err(GitServiceError::BranchNotFound(branch_name.to_string())),
},
}
}
pub fn check_branch_exists(
&self,
repo_path: &Path,
branch_name: &str,
) -> Result<bool, GitServi... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>lid_branch_prefix("foo/"));
assert!(!is_valid_branch_prefix(".foo"));
}
}
<|fim_prefix|>pub fn is_valid_branch_prefix(prefix: &str) -> bool {
if prefix.is_empty() {
return true;
}
if prefix.contains('/') {
return false;
}
git2::Branch::name_is_valid(&forma... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{
fs,
io::Write,
path::{Path, PathBuf},
};
use git::{GitCli, GitCliError, GitService};
use git2::{PushOptions, Repository, build::CheckoutBuilder};
use tempfile::TempDir;
// Avoid direct git CLI usage in tests; exercise GitService instead.
fn write_file<P: AsRef<Path>>(base: P, rel:... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{
fs,
io::Write,
path::{Path, PathBuf},
};
use git::{GitCli, GitServ<|fim_suffix|>_ = s.commit(&repo_path, "seed").unwrap();
// delete tracked file
std::fs::remove_file(repo_path.join("t2.txt")).unwrap();
assert!(!s.is_worktree_clean(&repo_path).unwrap());
// restor... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>//! Minimal helpers around the Azure CLI (`az repos`).
//!
//! This module provides low-level access to the Azure CLI for Azure DevOps
//! repository and pull request operations.
use std::{
ffi::{OsStr, OsString},
path::Path,
process::Command,
};
use chrono::{DateTime, Utc};
use db::models::... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|> let repo_id = repo_info.repo_id.clone();
let comments = task::spawn_blocking(move || {
cli.get_pr_threads(&organization_url, &project_id, &repo_id, pr_number)
})
.await
.map_err(|err| {
GitHostError::PullRequest(f... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>//! Git hosting provider detection from repository URLs.
use crate::types::ProviderKind;
/// Detect the git hosting provider from a remote URL.
///
/// Supports:
/// - GitHub.com: `https://github.com/owner/repo` or `git@github.com:owner/repo.git`
/// - GitHub Enterprise: URLs containing `github.` (e.g.,... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|> "--state",
"open",
"--json",
json_fields,
],
None,
)?;
let closed_raw = self.run(
[
"pr",
"list",
"--repo",
&repo_spec,
... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>//! GitHub hosting service implementation.
mod cli;
use std::{path::Path, time::Duration};
use async_trait::async_trait;
use backon::{ExponentialBuilder, Retryable};
pub use cli::GhCli;
use cli::{GhCliError, GitHubRepoInfo};
use tokio::task;
use tracing::info;
use crate::{
GitHostProvider,
typ... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>use enum_dispatch::enum_dispatch;
pub use types::{
CreatePrRequest, GitHostError, PrComment, PrCommentAuthor, PrReviewComment, ProviderKind,
PullRequestDetail, ReviewCommentUser, UnifiedPrComment,
};
use self::{azure::AzureDevOpsProvider, github::GitHubProvider};
#[async_trait]
#[enum_dispatch(G... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>mit_sha: d.merge_commit_sha,
}
}
}
<|fim_prefix|>use chrono::{DateTime, Utc};
use db::models::merge::{MergeStatus, PullRequestInfo};
use serde::{Deserialize, Serialize};
use thiserror::Error;
use ts_rs::TS;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, TS)]
#[serde(renam... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|> compiler so option_env!() sees it
if let Ok(val) = std::env::var("VK_SHARED_API_BASE") {
println!("cargo:rustc-env=VK_SHARED_API_BASE={}", val);
}
}
<|fim_prefix|>use std::path::Path;
fn main() {
// Load .env from the workspace root
let workspace_root = Path::new(env!("CARGO_MANI... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>wait
.map_err(ContainerError::KillFailed)
}
<|fim_prefix|>use command_group::AsyncGroupChild;
use services::services::container::ContainerError;
pub(crate) as<|fim_middle|>ync fn kill_process_group(child: &mut AsyncGroupChild) -> Result<(), ContainerError> {
utils::process::kill_process_group... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{
collections::HashMap,
io,
path::{Path, PathBuf},
sync::Arc,
time::{Duration, Instant},
};
use anyhow::anyhow;
use async_trait::async_trait;
use command_group::AsyncGroupChild;
use db::{
DBService,
models::{
coding_agent_turn::CodingAgentTurn,
executi... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{
collections::HashSet,
fs,
path::{Path, PathBuf},
};
use anyhow::anyhow;
use globwalk::GlobWalkerBuilder;
use services::services::container::ContainerError;
/// Normalize pattern for cross-platform glob matching (convert backslashes to forward slashes)
fn normalize_pattern(pattern:... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>
}
fn remote_info(&self) -> &RemoteInfo {
&self.remote_info
}
fn preview_proxy(&self) -> &PreviewProxyService {
&self.preview_proxy
}
fn relay_hosts(&self) -> Result<&Arc<RelayHosts>, RelayHostsNotConfigured> {
self.relay_hosts.as_ref().ok_or(RelayHostsNo... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>Failed(e.to_string()))?;
if shell_name == "zsh" {
let _ = writer.write_all(b" PROMPT='$ '; RPROMPT=''\n");
let _ = writer.flush();
let _ = writer.write_all(b"\x0c");
let _ = writer.flush();
}
let mut read... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>base_url(log_prefix: &str) -> anyhow::Result<String> {
if let Ok(url) = std::env::var("VIBE_BACKEND_URL") {
tracing::info!(
"[{}] Using backend URL from VIBE_BACKEND_URL: {}",
log_prefix,
url
);
return Ok(url);
}
let host = std::env:... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>,
pub message: Option<String>,
}
pub mod task_server;
<|fim_prefix|>use serde::Deserialize;
#[derive(Debug, Deserialize)]
pub struc<|fim_middle|>t ApiResponseEnvelope<T> {
pub success: bool,
pub data: Option<T><|endoftext|> | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>session metadata for the active MCP context when available. {}",
instruction
);
}
ServerInfo::new(ServerCapabilities::builder().enable_tools().build())
.with_server_info(Implementation::new("vibe-kanban-mcp", "1.0.0"))
.with_protocol_ver... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>loaded, get_context tool available");
}
self.context = context;
Ok(self)
}
pub fn mode(&self) -> &McpMode {
&self.mode
}
async fn fetch_context_at_startup(&self) -> anyhow::Result<Option<McpContext>> {
let current_dir = std::env::current_dir().con... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>ext_tools_router, vis = "pub")]
impl McpServer {
#[tool(
description = "Return project, issue, workspace, and orchestrator-session metadata for the current MCP context."
)]
async fn get_context(&self) -> Result<CallToolResult, ErrorData> {
let context = self.context.as_ref().ex... | fim | BloopAI/vibe-kanban | rust |
use api_types::{
CreateIssueAssigneeRequest, IssueAssignee, ListIssueAssigneesResponse, MutationResponse,
};
use rmcp::{
ErrorData, handler::server::wrapper::Parameters, model::CallToolResult, schemars, tool,
tool_router,
};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use super::McpServer;
#[deri... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use api_types::{
CreateIssueRelationshipRequest, IssueRelationship, IssueRelationshipType, MutationResponse,
};
use rmcp::{
ErrorData, handler::server::wrapper::Parameters, model::CallToolResult, schemars, tool,
tool_router,
};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use super::M... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>_json(self.client.get(&url)).await {
Ok(r) => r,
Err(e) => return Ok(Self::tool_error(e)),
};
let issue_tags = response
.issue_tags
.into_iter()
.map(|issue_tag| IssueTagSummary {
id: issue_tag.id.to_string(),
... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::str::FromStr;
use api_types::{Issue, ListProjectStatusesResponse, ProjectStatus};
use db::models::{execution_process::ExecutionProcessStatus, tag::Tag};
use executors::executors::BaseCodingAgent;
use regex::Regex;
use rmcp::{
ErrorData,
model::{CallToolResult, Content},
};
use serde::{De... | fim | BloopAI/vibe-kanban | rust |
use api_types::{ListMembersResponse, ListOrganizationsResponse};
use rmcp::{
ErrorData, handler::server::wrapper::Parameters, model::CallToolResult, schemars, tool,
tool_router,
};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use super::McpServer;
#[derive(Debug, Serialize, schemars::JsonSchema)]
stru... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>ity(&p) {
Ok(priority) => Some(priority),
Err(e) => return Ok(McpServer::tool_error(e)),
},
None => None,
};
let payload = CreateIssueRequest {
id: None,
project_id,
status_id,
title,
... | fim | BloopAI/vibe-kanban | rust |
use api_types::ListProjectsResponse;
use rmcp::{
ErrorData, handler::server::wrapper::Parameters, model::CallToolResult, schemars, tool,
tool_router,
};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use super::McpServer;
#[derive(Debug, Deserialize, schemars::JsonSchema)]
struct McpListProjectsRequest ... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>arameters(UpdateDevServerScriptRequest { repo_id, script }): Parameters<
UpdateDevServerScriptRequest,
>,
) -> Result<CallToolResult, ErrorData> {
let url = self.url(&format!("/api/repos/{}", repo_id));
let script_value = if script.is_empty() {
None
... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use db::models::{
execution_process::{ExecutionProcess, ExecutionProcessStatus},
session::Session,
};
use rmcp::{
ErrorData, handler::server::wrapper::Parameters, model::CallToolResult, schemars, tool,
tool_router,
};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use super::McpServ... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|> executor: base_executor,
variant,
model_id: None,
agent_id: None,
reasoning_id: None,
permission_policy: None,
},
prompt: workspace_prompt,
attachment_ids: None,
};
... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>) = self
.send_empty_json(self.client.delete(&url).query(&[
("delete_remote", delete_remote),
("delete_branches", delete_branches),
]))
.await
{
return Ok(Self::tool_error(e));
}
McpServer::success(&Mc... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use axum::{
body::{Body, to_bytes},
extract::{
Request,
ws::{WebSocketUpgrade, rejection::WebSocketUpgradeRejection},
},
http::StatusCode,
response::{IntoResponse, Respons<|fim_suffix|>TEWAY, "Preview upstream unavailable").into_response();
}
};
relay_h... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>){let s=e.split("/");s[s.length-1]=r,r=s.join("/")}return r},Gt=e=>({file:e.file,mappings:(0,Ze.decode)(e.mappings),names:e.names,sourceRoot:e.sourceRoot,sources:e.sources,sourcesContent:e.sourcesContent,version:3}),Vt=e=>{let t=e.sections.map(({map:r,offset:a})=>({map:{...r,mappings:(0,Ze.decode)(r.mappi... | fim | BloopAI/vibe-kanban | javascript |
<|fim_prefix|>(function() {
'use strict';
// =============================================================================
// === CORE: State & Utilities ===
// =============================================================================
var SOURCE = 'click-to-component';
var inspectModeActive = false;
... | fim | BloopAI/vibe-kanban | javascript |
<|fim_suffix|>eturn result;
};
window.addEventListener('message', function(event) {
if (!event.data || event.data.source !== SOURCE || event.data.type !== 'navigate') {
return;
}
var payload = event.data.payload;
if (!payload) return;
switch (payload.action) {
case 'back':
... | fim | BloopAI/vibe-kanban | javascript |
<|fim_suffix|>n;
}
var command = event.data.command;
switch (command) {
case 'toggle-eruda':
if (window.eruda._isShow) {
window.eruda.hide();
} else {
window.eruda.show();
}
break;
case 'show-eruda':
window.eruda.show();
... | fim | BloopAI/vibe-kanban | javascript |
<|fim_prefix|>//! Preview Proxy Server Module
//!
//! Provides a separate HTTP server for serving preview iframe content.
//! This isolates preview content from the main application for security.
//!
//! The proxy listens on a separate port and routes requests based on the
//! Host header subdomain. A request to `{port... | fim | BloopAI/vibe-kanban | rust |
use axum::http::HeaderMap;
pub(crate) const SKIP_REQUEST_HEADERS: &[&str] = &[
"host",
"connection",
"transfer-encoding",
"upgrade",
"proxy-connection",
"keep-alive",
"te",
"trailer",
"sec-websocket-key",
"sec-websocket-version",
"sec-websocket-extensions",
"accept-encod... | fim | BloopAI/vibe-kanban | rust |
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
use ed25519_dalek::VerifyingKey;
use http::{HeaderMap, HeaderName, Method};
use relay_control::signing::{
NONCE_HEADER, REQUEST_SIGNATURE_HEADER, RelaySigningService, RequestSignature... | fim | BloopAI/vibe-kanban | rust |
pub mod signing;
use tokio::sync::RwLock;
use tokio_util::sync::CancellationToken;
/// Controls the lifecycle of the relay tunnel connection.
///
/// Start/stop can be called from login/logout handlers to dynamically
/// manage the relay without restarting the server.
pub struct RelayControl {
/// Token used to c... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>equest for relay proxy authentication.
pub fn sign_request(
&self,
signing_session_id: Uuid,
method: &str,
path_and_query: &str,
body: &[u8],
) -> RequestSignature {
build_request_signature(
&self.server_signing_key,
signing_s... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>y(RelayApiError::Other(
"WebRTC offer response missing SDP answer".to_string(),
))
})?;
let client = WebRtcClient::connect(webrtc_offer, &answer.sdp, shutdown).await?;
Ok(client)
}
async fn load_relay_host_credentials_map() -> HashMap<Uuid, RelayHostCredentials> {
let... | fim | BloopAI/vibe-kanban | rust |
use std::{collections::HashMap, sync::Arc};
use tokio::{net::TcpListener, sync::Mutex};
use tokio_util::sync::CancellationToken;
use uuid::Uuid;
use crate::RelayHost;
#[derive(Clone)]
pub struct TunnelManager {
tunnels: Arc<Mutex<HashMap<Uuid, ActiveTunnel>>>,
shutdown: CancellationToken,
}
struct ActiveTun... | fim | BloopAI/vibe-kanban | rust |
<|fim_suffix|>t(WebRtcConnectionState::Connecting);
true
}
WebRtcConnectionState::Connected(client) if !client.is_connected() => {
e.insert(WebRtcConnectionState::Connecting);
true
}
_ => false,
... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>//! Shared relay WebSocket transport message protocol.
//!
//! Defines transport-agnostic frame/message types and conversions between
//! native WebSocket messages and relay frame envelopes.
use anyhow::Context as _;
use axum::extract::ws::{CloseFrame as AxumCloseFrame, Message as AxumMessage};
use serde... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::sync::Arc;
use relay_tunnel::server_bin::{
auth::JwtService, config::RelayServerConfig, db, routes, state::RelayAppState,
};
use tracing_subscriber::{EnvFilter, fmt, layer::SubscriberExt, util::SubscriberInitExt};
#[tokio::main]
async fn main() -> anyhow::Result<()> {
// Initialise trac... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>pub mod serve<|fim_suffix|>_bin;
<|fim_middle|>r<|endoftext|> | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use std::{collections::HashSet, sync::Arc};
use api_types::User;
use axum::{
body::Body,
extract::State,
http::{Request, StatusCode},
middleware::Next,
response::{IntoResponse, Response},
};
use axum_extra::headers::{Authorization, HeaderMapExt, authorizat<|fim_suffix|> return E... | fim | BloopAI/vibe-kanban | rust |
use std::env;
use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
use secrecy::SecretString;
#[derive(Debug, Clone)]
pub struct RelayServerConfig {
pub database_url: String,
pub listen_addr: String,
pub jwt_secret: SecretString,
}
#[derive(Debug, thiserror::Error)]
pub enum C... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>pub use api_types::AuthSession;
use chrono::Duration;
use sqlx::PgPool;
use thiserror::Error;
use uuid::Uuid;
#[derive(Debug, Error)]
pub enum AuthSessionError {
#[error("auth session not found")]
NotFound,
#[error(transparent)]
Database(#[from] sqlx::Error),
}
pub const MAX_SESSION_INAC... | fim | BloopAI/vibe-kanban | rust |
<|fim_prefix|>use sqlx::PgPool;
use uuid::Uuid;
use super::identity_errors::IdentityError;
pub struct HostRepository<'a> {
pool: &'a PgPool,
}
impl<'a> HostRepository<'a> {
pub fn new(pool: &'a PgPool) -> Self {
Self { pool }
}
/// Find or create a host for the given user and machine identit... | fim | BloopAI/vibe-kanban | rust |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.