Modules/Taskboard/private/TaskServerSync.cpp
Шурупов Илья Викторович 42715ad369 Taskboard: board model, MCP client and view
2026-11-01 12:19:53 +03:00

779 lines
28 KiB
C++

#include "TaskServerSync.hpp"
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <map>
#include <memory>
#include <set>
using namespace tp;
using namespace tp::taskboard;
using namespace tp::ui;
namespace {
picojson::value number(double value) { return picojson::value(value); }
double numberOr(const picojson::object& object, const char* key, double fallback) {
auto found = object.find(key);
return found != object.end() && found->second.is<double>() ? found->second.get<double>() : fallback;
}
std::string stringOr(const picojson::object& object, const char* key, const std::string& fallback) {
auto found = object.find(key);
return found != object.end() && found->second.is<std::string>() ? found->second.get<std::string>() : fallback;
}
std::optional<NodeId> idOf(const picojson::object& object, const char* key) {
auto found = object.find(key);
if (found == object.end() || !found->second.is<double>()) return std::nullopt;
return NodeId(found->second.get<double>());
}
const picojson::array& arrayOf(const picojson::object& object, const char* key) {
static const picojson::array empty;
auto found = object.find(key);
return found != object.end() && found->second.is<picojson::array>() ? found->second.get<picojson::array>() : empty;
}
int channel(halnf value) { return int(std::lround(std::clamp(value, 0.0f, 1.0f) * 255)); }
std::vector<std::string> stringsOf(const picojson::object& object, const char* key) {
std::vector<std::string> values;
for (const picojson::value& entry : arrayOf(object, key))
if (entry.is<std::string>()) values.push_back(entry.get<std::string>());
return values;
}
std::optional<LaunchSettings> launchSettingsFrom(const std::string& json) {
picojson::value parsed;
if (json.empty() || !picojson::parse(parsed, json).empty() || !parsed.is<picojson::object>()) return std::nullopt;
const picojson::object& object = parsed.get<picojson::object>();
return LaunchSettings{ stringOr(object, "agent_model", ""),
stringOr(object, "harness", "claude-code"),
stringOr(object, "effort", ""),
stringOr(object, "permission_mode", "auto") };
}
Task taskFromRow(const picojson::object& row) {
Task task;
task.title = stringOr(row, "title", "");
task.description = stringOr(row, "description", "");
task.status = statusFromName(stringOr(row, "status", "backlog")).value_or(TaskStatus::Backlog);
task.order = int(numberOr(row, "order_index", 0));
task.agentModel = stringOr(row, "agent_model", task.agentModel);
task.harness = stringOr(row, "harness", task.harness);
task.color = colorFromHex(stringOr(row, "color", ""));
task.effort = stringOr(row, "effort", "");
task.permissionMode = stringOr(row, "permission_mode", "");
task.session.state = sessionStateFromName(stringOr(row, "session_state", ""));
task.session.detail = stringOr(row, "session_detail", "");
task.session.launchedWith = launchSettingsFrom(stringOr(row, "session_launch", ""));
task.workspace = stringOr(row, "workspace", "");
return task;
}
std::optional<Vec2F> rowPosition(const picojson::object& row) {
auto x = row.find("x");
auto y = row.find("y");
if (x == row.end() || y == row.end() || !x->second.is<double>() || !y->second.is<double>()) return std::nullopt;
return Vec2F(halnf(x->second.get<double>()), halnf(y->second.get<double>()));
}
}
std::string tp::taskboard::colorToHex(const RGBA& color) {
char text[8];
std::snprintf(text, sizeof(text), "#%02x%02x%02x", channel(color.r), channel(color.g), channel(color.b));
return text;
}
std::optional<RGBA> tp::taskboard::colorFromHex(const std::string& text) {
unsigned red = 0;
unsigned green = 0;
unsigned blue = 0;
if (text.size() != 7 || text[0] != '#' || std::sscanf(text.c_str() + 1, "%2x%2x%2x", &red, &green, &blue) != 3)
return std::nullopt;
return RGBA(halnf(red) / 255, halnf(green) / 255, halnf(blue) / 255, 1);
}
const char* tp::taskboard::serverFieldName(TaskField field) {
switch (field) {
case TaskField::Title: return "title";
case TaskField::Description: return "description";
case TaskField::Order: return "order_index";
case TaskField::AgentModel: return "agent_model";
case TaskField::Harness: return "harness";
case TaskField::Effort: return "effort";
case TaskField::PermissionMode: return "permission_mode";
case TaskField::Status: return "status";
case TaskField::Color: return "color";
}
return "";
}
picojson::value tp::taskboard::fieldValue(const Task& task, TaskField field) {
switch (field) {
case TaskField::Title: return picojson::value(task.title);
case TaskField::Description: return picojson::value(task.description);
case TaskField::Order: return picojson::value(double(task.order));
case TaskField::AgentModel: return picojson::value(task.agentModel);
case TaskField::Harness: return picojson::value(task.harness);
case TaskField::Effort: return task.effort.empty() ? picojson::value() : picojson::value(task.effort);
case TaskField::PermissionMode:
return task.permissionMode.empty() ? picojson::value() : picojson::value(task.permissionMode);
case TaskField::Status: return picojson::value(std::string(statusName(task.status)));
case TaskField::Color: return task.color ? picojson::value(colorToHex(*task.color)) : picojson::value();
}
return {};
}
void tp::taskboard::setFieldValue(Task& task, TaskField field, const picojson::value& value) {
switch (field) {
case TaskField::Title: task.title = value.to_str(); break;
case TaskField::Description: task.description = value.to_str(); break;
case TaskField::Order:
if (value.is<double>()) task.order = int(value.get<double>());
break;
case TaskField::AgentModel: task.agentModel = value.to_str(); break;
case TaskField::Harness: task.harness = value.to_str(); break;
case TaskField::Effort: task.effort = value.is<std::string>() ? value.get<std::string>() : std::string(); break;
case TaskField::PermissionMode:
task.permissionMode = value.is<std::string>() ? value.get<std::string>() : std::string();
break;
case TaskField::Status: task.status = statusFromName(value.to_str()).value_or(task.status); break;
case TaskField::Color: task.color = value.is<std::string>() ? colorFromHex(value.to_str()) : std::nullopt; break;
}
}
std::string tp::taskboard::fieldLabel(TaskField field) {
switch (field) {
case TaskField::Title: return "Title";
case TaskField::Description: return "Description";
case TaskField::Order: return "Order";
case TaskField::AgentModel: return "Model";
case TaskField::Harness: return "Harness";
case TaskField::Effort: return "Effort";
case TaskField::PermissionMode: return "Mode";
case TaskField::Status: return "Status";
case TaskField::Color: return "Color";
}
return "";
}
namespace {
NodeLayout layoutFromRow(const picojson::object& row, const NodeLayout& fallback) {
NodeLayout layout = fallback;
if (const std::optional<Vec2F> position = rowPosition(row)) layout.position = *position;
layout.width = halnf(numberOr(row, "width", fallback.width));
layout.bodyHeight = halnf(numberOr(row, "body_height", fallback.bodyHeight));
layout.collapsed = numberOr(row, "collapsed", 0) != 0;
return layout;
}
void applyLayout(Node& node, const NodeLayout& layout) {
node.position = layout.position;
node.width = layout.width;
node.bodyHeight = layout.bodyHeight;
node.collapsed = layout.collapsed;
}
picojson::value layoutJson(NodeId id, const NodeLayout& layout) {
picojson::object object;
object["task_id"] = picojson::value(double(id));
object["x"] = picojson::value(double(layout.position.x));
object["y"] = picojson::value(double(layout.position.y));
object["width"] = picojson::value(double(layout.width));
object["body_height"] = picojson::value(double(layout.bodyHeight));
object["collapsed"] = picojson::value(layout.collapsed);
return picojson::value(object);
}
picojson::value linkJson(const TaskLink& link, const std::set<NodeId>& created) {
auto endpoint = [&](NodeId id) {
return created.count(id) ? picojson::value(-double(id)) : picojson::value(double(id));
};
picojson::object object;
object["kind"] = picojson::value(link.kind == LinkKind::Parent ? "parent" : "dependency");
object["from"] = endpoint(link.from);
object["to"] = endpoint(link.to);
return picojson::value(object);
}
PortRef outputPort(const TaskLink& link) {
return TaskBoard::output(link.from, link.kind == LinkKind::Parent ? TaskOutput::Children : TaskOutput::Unblocks);
}
PortRef inputPort(const TaskLink& link) {
return TaskBoard::input(link.to, link.kind == LinkKind::Parent ? TaskPort::Parent : TaskPort::DependsOn);
}
}
TaskServerSync::TaskServerSync(TaskBoard& board, McpClient& client) :
mBoard(board),
mClient(client) {}
bool TaskServerSync::load() {
const McpToolResult result = mClient.callToolBlocking("get_board", {});
if (!result.ok || !result.value.is<picojson::object>()) {
reportError(result.error.empty() ? "get_board returned no board" : result.error);
return false;
}
applyBoard(result.value.get<picojson::object>());
return true;
}
void TaskServerSync::processResponses() { mClient.dispatchCompletions(); }
void TaskServerSync::pollForChanges() {
if (mPollInFlight || mSaving || isViewingHistory()) return;
mPollInFlight = true;
mClient.callTool("get_board_revision", {}, [this](const McpToolResult& result) {
mPollInFlight = false;
if (!result.ok) {
reportError(result.error);
return;
}
if (result.value.to_str() != mRevision) requestReload();
});
if (++mSubrouterPollTick >= 30) {
mSubrouterPollTick = 0;
loadSubrouterInfo();
}
}
void TaskServerSync::loadSubrouterInfo() {
if (mSubrouterInFlight || !mOnSubrouterInfo) return;
mSubrouterInFlight = true;
mClient.callTool("get_subrouter_status", {}, [this](const McpToolResult& result) {
mSubrouterInFlight = false;
if (!result.ok || !result.value.is<picojson::object>()) return;
const picojson::object& object = result.value.get<picojson::object>();
SubrouterInfo info;
const auto availIt = object.find("available");
info.available = availIt != object.end() && availIt->second.is<bool>() && availIt->second.get<bool>();
info.loginHint = stringOr(object, "login_hint", "");
const auto accountsIt = object.find("accounts");
if (accountsIt != object.end() && accountsIt->second.is<picojson::object>()) {
for (const auto& [provider, pool] : accountsIt->second.get<picojson::object>()) {
if (!pool.is<picojson::object>()) continue;
for (const picojson::value& entry : arrayOf(pool.get<picojson::object>(), "accounts")) {
if (!entry.is<picojson::object>()) continue;
const picojson::object& acc = entry.get<picojson::object>();
SubrouterAccount account;
account.email = stringOr(acc, "email", "");
const auto coolIt = acc.find("coolingDownUntil");
if (coolIt != acc.end() && coolIt->second.is<std::string>()) {
account.coolingDown = true;
account.cooldownUntil = coolIt->second.get<std::string>();
}
info.accounts.push_back(std::move(account));
}
}
}
mOnSubrouterInfo(info);
});
}
void TaskServerSync::requestReload() {
if (mSaving || isViewingHistory()) return;
mPollInFlight = true;
const unsigned generation = mBoardGeneration;
mClient.callTool("get_board", {}, [this, generation](const McpToolResult& result) {
mPollInFlight = false;
if (generation != mBoardGeneration) return;
if (!result.ok || !result.value.is<picojson::object>()) {
reportError(result.error);
return;
}
applyBoard(result.value.get<picojson::object>());
});
}
bool TaskServerSync::viewHistoryAt(std::optional<double> moment) {
if (mSaving) {
reportError("wait for the save to finish before browsing history");
return false;
}
if (moment && !isViewingHistory() && hasUnsavedChanges()) {
reportError("save or discard your changes before browsing history");
return false;
}
mViewedMoment = moment;
if (mOnHistoryChanged) mOnHistoryChanged();
if (mHistoryInFlight) {
mQueuedMoment = moment;
return true;
}
requestBoard(moment);
return true;
}
void TaskServerSync::requestBoard(std::optional<double> moment) {
picojson::object arguments;
if (moment) arguments["at"] = number(*moment);
mHistoryInFlight = true;
const unsigned generation = ++mBoardGeneration;
mClient.callTool("get_board", arguments, [this, generation](const McpToolResult& result) {
boardArrived(result, generation);
});
}
void TaskServerSync::boardArrived(const McpToolResult& result, unsigned generation) {
mHistoryInFlight = false;
if (mQueuedMoment) {
const std::optional<double> next = *mQueuedMoment;
mQueuedMoment.reset();
requestBoard(next);
return;
}
if (generation != mBoardGeneration) return;
if (!result.ok || !result.value.is<picojson::object>()) {
reportError(result.error.empty() ? "get_board returned no board" : result.error);
return;
}
applyBoard(result.value.get<picojson::object>());
}
void TaskServerSync::applyHistorySpan(const picojson::object& board) {
auto found = board.find("history");
if (found == board.end() || !found->second.is<picojson::object>()) return;
const picojson::object& history = found->second.get<picojson::object>();
auto moment = [&](const char* key) -> std::optional<double> {
auto entry = history.find(key);
if (entry == history.end() || !entry->second.is<double>()) return std::nullopt;
return entry->second.get<double>();
};
const HistorySpan span{ moment("first"), moment("last") };
const bool grew = span.last != mHistorySpan.last;
mHistorySpan = span;
if (mOnHistoryChanged) mOnHistoryChanged();
if (grew) loadHistoryChanges();
}
void TaskServerSync::loadHistoryChanges() {
mClient.callTool("get_history_moments", {}, [this](const McpToolResult& result) {
if (!result.ok || !result.value.is<picojson::array>()) return;
std::vector<double> moments;
for (const picojson::value& entry : result.value.get<picojson::array>())
if (entry.is<double>()) moments.push_back(entry.get<double>());
mHistoryChanges = std::move(moments);
if (mOnHistoryChanged) mOnHistoryChanged();
});
}
BoardChanges TaskServerSync::unsavedChanges() const {
return BoardChanges::between(mSaved, BoardSnapshot::capture(mBoard));
}
// An empty server palette means the board default is in effect, so the default is what counts as saved.
// Merging a server board: every piece the user has not changed locally (live board equals mSaved) takes the
// server's value; pieces with unsaved local changes keep the local value, and a field both sides changed
// differently becomes a conflict. mSaved then becomes the server board, so the unsaved difference stays exact.
void TaskServerSync::applyBoard(const picojson::object& board) {
const BoardSnapshot local = BoardSnapshot::capture(mBoard);
applyPalette(board, local);
const std::vector<TaskLink> parentLinks = applyTasks(board, local);
applyLinks(board, parentLinks, local);
mRevision = stringOr(board, "revision", "");
applyHistorySpan(board);
if (mOnBoardReloaded) mOnBoardReloaded();
}
void TaskServerSync::applyPalette(const picojson::object& board, const BoardSnapshot& local) {
std::vector<std::string> server;
for (const picojson::value& entry : arrayOf(board, "palette"))
if (entry.is<std::string>()) server.push_back(entry.get<std::string>());
if (server.empty()) {
for (const RGBA& color : kTaskColors)
server.push_back(colorToHex(color));
}
const bool unchangedLocally = local.palette == mSaved.palette;
mSaved.palette = server;
if (!unchangedLocally) return;
std::vector<RGBA> colors;
for (const std::string& hex : server)
if (const auto color = colorFromHex(hex)) colors.push_back(*color);
mBoard.setColorPalette(colors);
}
std::vector<TaskLink> TaskServerSync::applyTasks(const picojson::object& board, const BoardSnapshot& local) {
NodeGraph& graph = mBoard.graph();
std::set<NodeId> present;
std::vector<TaskLink> parentLinks;
halnf nextColumn = 40;
for (const picojson::value& entry : arrayOf(board, "tasks")) {
if (!entry.is<picojson::object>()) continue;
const picojson::object& row = entry.get<picojson::object>();
const std::optional<NodeId> id = idOf(row, "id");
if (!id) continue;
present.insert(*id);
const Task incoming = taskFromRow(row);
const bool known = mSaved.tasks.count(*id) > 0;
const bool deletedLocally = known && !local.tasks.count(*id);
if (const std::optional<NodeId> parent = idOf(row, "parent_id"))
parentLinks.push_back({ LinkKind::Parent, *parent, *id });
NodeLayout fallback{ Vec2F(nextColumn, 40.0f),
mBoard.graph().type(mBoard.taskType()).width,
mBoard.graph().type(mBoard.taskType()).bodyHeight,
false };
if (!rowPosition(row)) nextColumn += 260;
const NodeLayout layout = layoutFromRow(row, fallback);
if (deletedLocally) {
TaskRecord& saved = mSaved.tasks[*id];
for (TaskField field : persistentFields())
saved.fields[field] = fieldValue(incoming, field);
saved.layout = layout;
continue;
}
if (!graph.findNode(*id)) {
mBoard.addTaskWithId(*id, incoming, layout.position);
applyLayout(*graph.findNode(*id), layout);
} else {
mergeTask(*id, incoming, layout, local);
}
TaskRecord& saved = mSaved.tasks[*id];
for (TaskField field : persistentFields())
saved.fields[field] = fieldValue(incoming, field);
saved.layout = layout;
}
std::vector<NodeId> removed;
for (auto it = mSaved.tasks.begin(); it != mSaved.tasks.end();) {
if (present.count(it->first)) {
++it;
continue;
}
removed.push_back(it->first);
it = mSaved.tasks.erase(it);
}
graph.removeNodes(removed);
return parentLinks;
}
void TaskServerSync::mergeTask(NodeId id, const Task& incoming, const NodeLayout& layout, const BoardSnapshot& local) {
Task& task = *mBoard.task(id);
task.session = incoming.session;
task.workspace = incoming.workspace;
const TaskRecord& saved = mSaved.tasks.at(id);
const TaskRecord& mine = local.tasks.at(id);
for (TaskField field : persistentFields()) {
const picojson::value theirs = fieldValue(incoming, field);
const picojson::value& base = saved.fields.at(field);
const picojson::value& current = mine.fields.at(field);
if (theirs == base) continue;
const bool changedLocally = current != base || isEditing(id, field);
if (!changedLocally) {
setFieldValue(task, field, theirs);
continue;
}
if (current != theirs) addConflict({ id, field, current, theirs });
}
if (mine.layout == saved.layout) applyLayout(*mBoard.graph().findNode(id), layout);
}
void TaskServerSync::applyLinks(
const picojson::object& board, const std::vector<TaskLink>& parentLinks, const BoardSnapshot& local
) {
std::set<TaskLink> server(parentLinks.begin(), parentLinks.end());
for (const picojson::value& entry : arrayOf(board, "dependencies")) {
if (!entry.is<picojson::object>()) continue;
const picojson::object& row = entry.get<picojson::object>();
const std::optional<NodeId> task = idOf(row, "task_id");
const std::optional<NodeId> dependsOn = idOf(row, "depends_on_id");
if (task && dependsOn) server.insert({ LinkKind::Dependency, *dependsOn, *task });
}
for (const TaskLink& link : mSaved.links) {
const bool goneOnServer = !server.count(link);
const bool keptLocally = local.links.count(link) > 0;
if (goneOnServer && keptLocally) disconnect(link);
}
for (const TaskLink& link : server) {
const bool newOnServer = !mSaved.links.count(link);
if (newOnServer) connect(link);
}
mSaved.links = server;
}
void TaskServerSync::connect(const TaskLink& link) {
if (!mBoard.graph().findNode(link.from) || !mBoard.graph().findNode(link.to)) return;
mBoard.graph().connect(outputPort(link), inputPort(link));
}
void TaskServerSync::disconnect(const TaskLink& link) {
mBoard.graph().disconnect({ outputPort(link), inputPort(link) });
}
void TaskServerSync::save() {
if (mSaving) return;
if (isViewingHistory()) {
reportError("a past board is read-only; return to Live to save");
return;
}
const BoardChanges changes = unsavedChanges();
if (changes.empty()) return;
mSaving = true;
mClient.callTool("save_board", saveRequest(changes), [this, changes](const McpToolResult& result) {
finishSave(result, changes);
});
}
picojson::object TaskServerSync::saveRequest(const BoardChanges& changes) const {
const BoardSnapshot current = BoardSnapshot::capture(mBoard);
const std::set<NodeId> created(changes.created.begin(), changes.created.end());
picojson::object request;
picojson::array createdTasks;
for (NodeId id : changes.created) {
const TaskRecord& record = current.tasks.at(id);
picojson::object entry = layoutJson(id, record.layout).get<picojson::object>();
entry.erase("task_id");
entry["ref"] = picojson::value(-double(id));
for (TaskField field : persistentFields())
entry[serverFieldName(field)] = record.fields.at(field);
createdTasks.emplace_back(entry);
}
request["created"] = picojson::value(createdTasks);
std::map<NodeId, std::pair<picojson::object, picojson::object>> editsByTask;
for (const FieldEdit& edit : changes.edits) {
editsByTask[edit.task].first[serverFieldName(edit.field)] = edit.value;
editsByTask[edit.task].second[serverFieldName(edit.field)] = edit.expected;
}
picojson::array edits;
for (const auto& [id, edit] : editsByTask) {
picojson::object entry;
entry["task_id"] = picojson::value(double(id));
entry["changes"] = picojson::value(edit.first);
entry["expected"] = picojson::value(edit.second);
edits.emplace_back(entry);
}
request["edits"] = picojson::value(edits);
picojson::array layouts;
for (NodeId id : changes.layouts)
layouts.push_back(layoutJson(id, current.tasks.at(id).layout));
request["layouts"] = picojson::value(layouts);
picojson::array deleted;
for (NodeId id : changes.deleted)
deleted.emplace_back(double(id));
request["deleted"] = picojson::value(deleted);
picojson::array added;
for (const TaskLink& link : changes.linksAdded)
added.push_back(linkJson(link, created));
request["links_added"] = picojson::value(added);
picojson::array removed;
for (const TaskLink& link : changes.linksRemoved)
removed.push_back(linkJson(link, created));
request["links_removed"] = picojson::value(removed);
if (changes.palette) {
picojson::array palette;
for (const std::string& color : *changes.palette)
palette.emplace_back(color);
request["palette"] = picojson::value(palette);
}
return request;
}
void TaskServerSync::finishSave(const McpToolResult& result, const BoardChanges& changes) {
mSaving = false;
if (!result.ok || !result.value.is<picojson::object>()) {
reportError("save failed, nothing was written: " + result.error);
return;
}
const picojson::object& response = result.value.get<picojson::object>();
if (response.count("ids") && response.at("ids").is<picojson::object>())
adoptCreatedIds(response.at("ids").get<picojson::object>());
for (const picojson::value& entry : arrayOf(response, "conflicts")) {
if (!entry.is<picojson::object>()) continue;
const picojson::object& conflict = entry.get<picojson::object>();
const std::optional<NodeId> id = idOf(conflict, "task_id");
const std::string field = stringOr(conflict, "field", "");
for (TaskField candidate : persistentFields()) {
if (!id || serverFieldName(candidate) != field) continue;
const picojson::object& current = conflict.at("current").get<picojson::object>();
addConflict({ *id, candidate, conflict.at("mine"), current.at(field) });
}
}
(void) changes;
requestReload();
if (mOnSaved) mOnSaved();
}
// Created tasks get their server id: their node is re-keyed in place so selection, links and layout survive.
void TaskServerSync::adoptCreatedIds(const picojson::object& ids) {
for (const auto& [reference, value] : ids) {
if (!value.is<double>()) continue;
const NodeId local = NodeId(-std::stod(reference));
const NodeId server = NodeId(value.get<double>());
mBoard.graph().renameNode(local, server);
const BoardSnapshot current = BoardSnapshot::capture(mBoard);
mSaved.tasks[server] = current.tasks.at(server);
}
}
void TaskServerSync::startSession(NodeId id) { sessionCall("start_session", id, {}); }
void TaskServerSync::restartSession(NodeId id, bool fresh) {
picojson::object arguments;
arguments["fresh"] = picojson::value(fresh);
sessionCall("restart_session", id, arguments);
}
void TaskServerSync::stopSession(NodeId id) { sessionCall("stop_session", id, {}); }
void TaskServerSync::listSecrets(std::function<void(std::vector<SecretEntry>)> onResult) {
mClient.callTool("list_secrets", {}, [this, onResult = std::move(onResult)](const McpToolResult& result) {
if (!result.ok || !result.value.is<picojson::array>()) {
if (!result.ok) reportError("list_secrets: " + result.error);
onResult({});
return;
}
std::vector<SecretEntry> entries;
for (const picojson::value& entry : result.value.get<picojson::array>()) {
if (!entry.is<picojson::object>()) continue;
const picojson::object& object = entry.get<picojson::object>();
entries.push_back({ stringOr(object, "key", ""), stringOr(object, "description", "") });
}
onResult(std::move(entries));
});
}
void TaskServerSync::setSecret(
const std::string& key, const std::string& value, const std::string& description,
std::function<void(bool, std::string)> onDone
) {
picojson::object arguments;
arguments["key"] = picojson::value(key);
arguments["value"] = picojson::value(value);
arguments["description"] = picojson::value(description);
mClient.callTool("set_secret", arguments, [onDone = std::move(onDone)](const McpToolResult& result) {
onDone(result.ok, result.ok ? std::string() : result.error);
});
}
void TaskServerSync::deleteSecret(const std::string& key, std::function<void(bool, std::string)> onDone) {
picojson::object arguments;
arguments["key"] = picojson::value(key);
mClient.callTool("delete_secret", arguments, [onDone = std::move(onDone)](const McpToolResult& result) {
onDone(result.ok, result.ok ? std::string() : result.error);
});
}
void TaskServerSync::sessionCall(const std::string& tool, NodeId id, picojson::object arguments) {
if (isViewingHistory()) {
reportError("sessions are not available on a past board; return to Live");
return;
}
if (!mSaved.tasks.count(id)) {
reportError("save the task before starting its session");
return;
}
arguments["task_id"] = number(double(id));
mClient.callTool(tool, arguments, [this, tool](const McpToolResult& result) {
if (!result.ok) {
reportError(tool + ": " + result.error);
return;
}
requestReload();
});
}
bool TaskServerSync::loadOptions() {
const McpToolResult result = mClient.callToolBlocking("get_options", {});
if (!result.ok || !result.value.is<picojson::object>()) return false;
const picojson::object& object = result.value.get<picojson::object>();
AgentOptions options;
for (const picojson::value& entry : arrayOf(object, "models")) {
if (!entry.is<picojson::object>()) continue;
const picojson::object& model = entry.get<picojson::object>();
options.models.push_back({ stringOr(model, "id", ""), stringOr(model, "label", "") });
}
for (const picojson::value& entry : arrayOf(object, "harnesses")) {
if (!entry.is<picojson::object>()) continue;
const picojson::object& harness = entry.get<picojson::object>();
options.harnesses.push_back({ stringOr(harness, "id", ""), stringOr(harness, "label", "") });
}
if (options.harnesses.empty()) options.harnesses = offlineAgentOptions().harnesses;
options.efforts = stringsOf(object, "efforts");
options.permissionModes = stringsOf(object, "permission_modes");
if (options.models.empty() || options.efforts.empty() || options.permissionModes.empty()) return false;
mOptions = std::move(options);
return true;
}
void TaskServerSync::beginEditing(NodeId id, TaskField field) { mEditing = std::make_pair(id, field); }
void TaskServerSync::endEditing() { mEditing.reset(); }
bool TaskServerSync::isEditing(NodeId id, TaskField field) const { return mEditing == std::make_pair(id, field); }
void TaskServerSync::addConflict(FieldConflict conflict) {
dropConflict(conflict.task, conflict.field);
mConflicts.push_back(std::move(conflict));
if (mOnConflictsChanged) mOnConflictsChanged();
}
bool TaskServerSync::dropConflict(NodeId id, TaskField field) {
const size_t removed = std::erase_if(mConflicts, [&](const FieldConflict& existing) {
return existing.task == id && existing.field == field;
});
return removed > 0;
}
// Keep mine: the local value stays and remains unsaved (it now differs from the server's), so Save writes it.
// Use theirs: the local value becomes the server's, so the field is no longer unsaved.
void TaskServerSync::resolveConflict(FieldConflict conflict, bool keepMine) {
dropConflict(conflict.task, conflict.field);
if (Task* task = mBoard.task(conflict.task))
setFieldValue(*task, conflict.field, keepMine ? conflict.mine : conflict.theirs);
if (mOnConflictsChanged) mOnConflictsChanged();
if (mOnBoardReloaded) mOnBoardReloaded();
}
void TaskServerSync::reportError(const std::string& error) {
mLastError = error;
if (mOnError) mOnError(error);
}