Merge anthropic admin package

This commit is contained in:
2026-10-24 07:47:06 +02:00
64 changed files with 7703 additions and 3 deletions
+339 -3
View File
@@ -1,13 +1,349 @@
#include "../AiDemos.hpp"
#include "../../fw/Router.hpp"
#include "../../fw/Templates.hpp"
#include "anthropic/admin/calls.h"
#include "anthropic/admin/gateway.h"
#include "anthropic/admin/reports.h"
#include "anthropic/admin/request.h"
#include "anthropic/admin/webhook.h"
#include "llm/error.h"
namespace molo::example::app {
// Anthropic Claude: admin API (orgs, workspaces, keys, usage, cost) and managed agents. Stub: the module agent fills this in.
// Anthropic admin: Admin API (organization, users, invites, workspaces, keys,
// service accounts, federation, RBAC, spend limits, plugins, webhooks, Claude
// Tag), usage and cost reports, and the Managed Agents surface, over the real
// src/anthropic/admin package. GET routes need no credential. Every route that
// calls Anthropic is a POST: 503 not_configured without a credential, 422 on
// bad input, 401 credential_rejected for a key of the wrong kind. Anything that
// is not a read is a dry run unless the body says "confirm":true.
namespace {
namespace adm = anthropic::admin;
using Json = clients::body::Json;
constexpr std::size_t kMaxBody = 256 * 1024;
const char kPage[] = R"ADMIN({% extends "base.html" %}
{% block content %}
<h1>Anthropic admin</h1>
<p class="hint">Organization, workspaces, keys, usage and cost reports, and Managed
Agents. Reads run as is; every write or delete is a dry run until you tick confirm.</p>
<p id="ad-config" class="hint">Checking credentials...</p>
<section class="ad">
<h2>Organization</h2>
<div class="ad-actions"><button id="ad-org" type="button" class="primary">Organization info</button></div>
<h2>Usage and cost</h2>
<label>Report
<select id="ad-report">
<option value="usage">Messages usage</option>
<option value="cost">Cost</option>
<option value="claude-code">Claude Code usage</option>
</select></label>
<label>Starting at <input id="ad-start" type="text" maxlength="40" placeholder="2026-10-01T00:00:00Z (Claude Code: 2026-10-01)"></label>
<label>Group by (comma separated) <input id="ad-group" type="text" maxlength="120" placeholder="model,workspace_id"></label>
<div class="ad-actions"><button id="ad-run-report" type="button">Run report</button></div>
<h2>Any call</h2>
<label>Call
<select id="ad-call"></select></label>
<label>Path ids (comma separated) <input id="ad-ids" type="text" maxlength="400"></label>
<label>Query (JSON object) <textarea id="ad-query" rows="2">{}</textarea></label>
<label>Body (JSON object) <textarea id="ad-body" rows="4">{}</textarea></label>
<label class="ad-check"><input id="ad-confirm" type="checkbox"> confirm (run writes and deletes for real)</label>
<div class="ad-actions"><button id="ad-send" type="button">Send</button></div>
<p id="ad-error" class="error" role="alert"></p>
<pre id="ad-out" class="ad-out"></pre>
</section>
<style>
.ad label{display:block;margin:.5rem 0}
.ad input[type=text],.ad textarea,.ad select{width:100%;box-sizing:border-box}
.ad-check{display:flex;gap:.5rem;align-items:center}
.ad-actions{display:flex;flex-wrap:wrap;gap:.5rem;margin:.5rem 0}
.ad-out{overflow:auto;max-height:24rem;white-space:pre-wrap;word-break:break-word}
</style>
<script src="/embedded/ai_anthropic_admin.js"></script>
{% endblock %}
)ADMIN";
fw::Response json_out(const Json& j, int status = 200) {
fw::Response res = fw::JsonResponse(j.dump(), status);
res.headers.set("Cache-Control", "no-store");
return res;
}
[[noreturn]] void bad(const std::string& why) { throw fw::HttpError(422, "validation_error", why); }
[[noreturn]] void rethrow(const llm::ApiError& e) {
if (e.type() == "NOT_CONFIGURED") throw fw::HttpError(503, "not_configured", e.message());
if (e.type() == "credential_rejected") throw fw::HttpError(e.http_status() == 403 ? 403 : 401, "credential_rejected", e.message());
if (e.type() == "INVALID_ARGUMENT") bad(e.message());
throw fw::HttpError(502, "anthropic_error", std::to_string(e.http_status()) + " " + e.type() + ": " + e.message());
}
template <typename F>
auto guarded(F&& f) -> decltype(f()) {
try {
return f();
} catch (const llm::ApiError& e) {
rethrow(e);
}
}
Json parse_body(const fw::Request& req) {
if (req.body.size() > kMaxBody) throw fw::HttpError(413, "payload_too_large", "body too large");
if (req.body.empty()) return Json::object();
try {
Json j = Json::parse(req.body);
if (!j.is_object()) bad("body must be a JSON object");
return j;
} catch (const clients::body::JsonError&) {
bad("body is not valid JSON");
}
}
std::string text(const Json& body, const char* key) {
const Json* v = body.find(key);
if (!v || v->is_null()) return "";
if (!v->is_string()) bad(std::string(key) + " must be a string");
return v->as_string();
}
bool flag(const Json& body, const char* key) {
const Json* v = body.find(key);
if (!v || v->is_null()) return false;
if (!v->is_bool()) bad(std::string(key) + " must be true or false");
return v->as_bool();
}
std::vector<std::string> strings(const Json& body, const char* key) {
std::vector<std::string> out;
const Json* v = body.find(key);
if (!v || v->is_null()) return out;
if (!v->is_array()) bad(std::string(key) + " must be an array of strings");
for (const Json& s : v->as_array()) {
if (!s.is_string()) bad(std::string(key) + " must be an array of strings");
out.push_back(s.as_string());
}
return out;
}
const char* kind_name(adm::Kind k) {
return k == adm::Kind::kRead ? "read" : k == adm::Kind::kWrite ? "write" : "destructive";
}
const char* auth_name(adm::Auth a) {
return a == adm::Auth::kAdmin ? "admin_key_or_oauth" : a == adm::Auth::kOAuth ? "oauth_token" : "api_key";
}
// Looks a call up by its table name; "name" and "name+beta" forms share names, the
// first row wins (the beta form carries a "beta" suffix in the name).
const adm::CallSpec* find_call(const std::string& name) {
for (std::size_t i = 0; i < adm::call_count(); ++i)
if (name == adm::spec_at(i).name) return &adm::spec_at(i);
return nullptr;
}
class AdminRoutes {
public:
explicit AdminRoutes(std::shared_ptr<adm::Gateway> gateway) : gateway_(std::move(gateway)) {}
Json status() const {
Json o = Json::object();
Json lanes = Json::object();
for (const adm::LaneInfo& l : gateway_->lanes()) {
Json s = Json::object();
s.set("env", Json(l.env));
s.set("state", Json(l.state == adm::LaneState::kReady ? "ready" : l.state == adm::LaneState::kMissing ? "missing" : "rejected"));
if (!l.reason.empty()) s.set("reason", Json(l.reason));
lanes.set(adm::KeyRules::name_of(l.lane), s);
}
o.set("lanes", lanes);
o.set("configured", Json(gateway_->ready(adm::Auth::kAdmin)));
o.set("calls", Json(static_cast<long>(adm::call_count())));
o.set("api_version", Json(adm::Gateway::kApiVersion));
return o;
}
Json calls() const {
Json arr = Json::array();
for (std::size_t i = 0; i < adm::call_count(); ++i) {
const adm::CallSpec& s = adm::spec_at(i);
Json c = Json::object();
c.set("name", Json(s.name));
c.set("http", Json(s.http));
c.set("path", Json(s.path));
c.set("kind", Json(kind_name(s.kind)));
c.set("credential", Json(auth_name(s.auth)));
c.set("beta", Json(s.beta));
arr.push(c);
}
Json o = Json::object();
o.set("calls", arr);
return o;
}
// Generic table-driven call: validate, dry-run non-reads, then send.
fw::Response call(const fw::Request& req) const {
Json b = parse_body(req);
std::string name = text(b, "call");
if (name.empty()) bad("call is required");
const adm::CallSpec* spec = find_call(name);
if (!spec) bad("unknown call " + name);
if (spec->wire != adm::Wire::kJson)
bad(name + " is a " + (spec->wire == adm::Wire::kSse ? "stream" : spec->wire == adm::Wire::kRaw ? "download" : "multipart upload") + " call and is not available here");
adm::Query query;
if (const Json* q = b.find("query")) {
if (!q->is_object()) bad("query must be a JSON object");
for (const auto& [k, v] : q->as_object()) {
if (v.is_array()) {
for (const Json& item : v.as_array()) {
if (!item.is_string() && !item.is_number()) bad(k + " values must be strings or numbers");
query.add(k, item.is_string() ? item.as_string() : std::to_string(item.as_int()));
}
} else if (v.is_string()) {
query.set(k, v.as_string());
} else if (v.is_number()) {
query.set_int(k, v.as_int());
} else if (v.is_bool()) {
query.set_bool(k, v.as_bool());
} else {
bad(k + " must be a string, number, boolean or array");
}
}
}
const Json* body = b.find("body");
if (body && !body->is_null() && !body->is_object()) bad("body must be a JSON object");
bool has_body = body && body->is_object() && !body->as_object().empty();
bool confirm = flag(b, "confirm");
adm::PreparedRequest p = guarded([&] {
return adm::RequestBuilder::prepare(find_enum(spec), strings(b, "ids"), &query,
(has_body || adm::RequestBuilder::names(spec->body).size() ? body : nullptr),
gateway_->workspace_id());
});
if (spec->kind != adm::Kind::kRead && !confirm) {
Json o = Json::object();
o.set("dry_run", Json(true));
o.set("would_send", Json(std::string(spec->http) + " " + p.target));
o.set("kind", Json(kind_name(spec->kind)));
o.set("hint", Json("send confirm:true to run it"));
return json_out(o);
}
return guarded([&] {
auto client = gateway_->client_for(spec->auth);
return json_out(client->request(p.method, p.target, p.body ? &*p.body : nullptr, p.headers));
});
}
fw::Response organization(const fw::Request&) const {
return guarded([&] {
adm::PreparedRequest p = adm::RequestBuilder::prepare(adm::Call::kOrganizationRetrieve, {}, nullptr, nullptr);
return json_out(gateway_->client_for(adm::Auth::kAdmin)->request(p.method, p.target, nullptr, p.headers));
});
}
fw::Response report(const fw::Request& req, int which) const {
Json b = parse_body(req);
std::string start = text(b, "starting_at");
std::string ending = text(b, "ending_at");
std::string page = text(b, "page");
long limit = 0;
if (const Json* l = b.find("limit")) {
if (!l->is_number()) bad("limit must be a number");
limit = l->as_int();
}
std::vector<std::string> group = strings(b, "group_by");
return guarded([&] {
adm::Query q;
adm::Call c;
if (which == 0) {
adm::MessagesUsageQuery m;
m.starting_at = start;
m.ending_at = ending;
m.limit = limit;
m.page = page;
m.group_by = group;
std::string w = text(b, "bucket_width");
if (!w.empty()) m.bucket_width = w;
q = m.to_query();
c = adm::Call::kUsageReportRetrieveMessages;
} else if (which == 1) {
adm::CostQuery m;
m.starting_at = start;
m.ending_at = ending;
m.limit = limit;
m.page = page;
m.group_by = group;
q = m.to_query();
c = adm::Call::kCostReportRetrieve;
} else {
adm::ClaudeCodeQuery m;
m.starting_at = start;
m.limit = limit;
m.page = page;
q = m.to_query();
c = adm::Call::kUsageReportRetrieveClaudeCode;
}
adm::PreparedRequest p = adm::RequestBuilder::prepare(c, {}, &q, nullptr);
return json_out(gateway_->client_for(adm::Auth::kAdmin)->request(p.method, p.target, nullptr, p.headers));
});
}
// Local: verifies a webhook signature; no credential involved.
fw::Response verify_webhook(const fw::Request& req) const {
Json b = parse_body(req);
std::string key = text(b, "signing_key"), payload = text(b, "payload");
if (key.empty()) bad("signing_key is required");
if (payload.empty()) bad("payload is required");
std::map<std::string, std::string> h{{"webhook-id", text(b, "webhook_id")},
{"webhook-timestamp", text(b, "webhook_timestamp")},
{"webhook-signature", text(b, "webhook_signature")}};
return guarded([&] {
adm::WebhookVerifier v(key);
std::string why;
bool ok = v.verify(payload, h, static_cast<long>(std::time(nullptr)), &why);
Json o = Json::object();
o.set("valid", Json(ok));
if (!ok) o.set("reason", Json(why));
return json_out(o);
});
}
private:
static adm::Call find_enum(const adm::CallSpec* spec) { return spec->call; }
std::shared_ptr<adm::Gateway> gateway_;
};
} // namespace
void register_ai_anthropicadmin_demo(fw::Router& router, Services& services) {
(void)router;
(void)services;
auto gateway = adm::Gateway::from_env();
auto routes = std::make_shared<AdminRoutes>(gateway);
fw::Environment* env = services.templates.get();
services.templates->add_template("ai_anthropic_admin.html", kPage);
services.add_feature("ai-anthropic-admin", "/ai/anthropic/admin");
router.get("/ai/anthropic/admin", "ai-anthropic-admin-page", [env](fw::Request) {
fw::TemplateCtx ctx;
ctx["title"] = std::string("Anthropic admin");
return fw::Response(200, env->render("ai_anthropic_admin.html", ctx), "text/html; charset=utf-8");
});
router.get("/ai/anthropic/admin/status", "ai-anthropic-admin-status",
[routes](fw::Request) { return json_out(routes->status()); });
router.get("/ai/anthropic/admin/calls", "ai-anthropic-admin-calls",
[routes](fw::Request) { return json_out(routes->calls()); });
router.post("/ai/anthropic/admin/call", "ai-anthropic-admin-call",
[routes](fw::Request req) { return routes->call(req); });
router.post("/ai/anthropic/admin/organization", "ai-anthropic-admin-organization",
[routes](fw::Request req) { return routes->organization(req); });
router.post("/ai/anthropic/admin/usage", "ai-anthropic-admin-usage",
[routes](fw::Request req) { return routes->report(req, 0); });
router.post("/ai/anthropic/admin/cost", "ai-anthropic-admin-cost",
[routes](fw::Request req) { return routes->report(req, 1); });
router.post("/ai/anthropic/admin/claude-code", "ai-anthropic-admin-claude-code",
[routes](fw::Request req) { return routes->report(req, 2); });
router.post("/ai/anthropic/admin/webhook/verify", "ai-anthropic-admin-webhook-verify",
[routes](fw::Request req) { return routes->verify_webhook(req); });
}
} // namespace molo::example::app
+59
View File
@@ -0,0 +1,59 @@
// Anthropic admin page: thin client over /ai/anthropic/admin/* (all limits server side).
(function () {
"use strict";
var $ = function (id) { return document.getElementById(id); };
var out = $("ad-out"), err = $("ad-error");
function post(path, body) {
err.textContent = "";
out.textContent = "...";
return fetch(path, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(body)
}).then(function (res) {
return res.text().then(function (t) {
var j;
try { j = JSON.parse(t); } catch (e) { j = { message: t }; }
if (!res.ok) {
err.textContent = j.message || ("HTTP " + res.status);
out.textContent = "";
} else {
out.textContent = JSON.stringify(j, null, 2);
}
});
}).catch(function (e) { err.textContent = String(e); out.textContent = ""; });
}
function json(id) {
try { return JSON.parse($(id).value || "{}"); }
catch (e) { err.textContent = "Not valid JSON: " + id; return null; }
}
fetch("/ai/anthropic/admin/status").then(function (r) { return r.json(); }).then(function (s) {
var l = s.lanes || {};
$("ad-config").textContent = "Admin key: " + (l.admin_key || {}).state +
", OAuth token: " + (l.oauth_token || {}).state + ", API key: " + (l.api_key || {}).state +
". " + s.calls + " calls, API version " + s.api_version + ".";
});
fetch("/ai/anthropic/admin/calls").then(function (r) { return r.json(); }).then(function (d) {
var sel = $("ad-call");
d.calls.forEach(function (c) {
var o = document.createElement("option");
o.value = c.name;
o.textContent = c.http + " " + c.name + (c.kind === "read" ? "" : " (" + c.kind + ")");
sel.appendChild(o);
});
});
$("ad-org").onclick = function () { post("/ai/anthropic/admin/organization", {}); };
$("ad-run-report").onclick = function () {
var group = $("ad-group").value.split(",").map(function (s) { return s.trim(); }).filter(Boolean);
post("/ai/anthropic/admin/" + $("ad-report").value, { starting_at: $("ad-start").value.trim(), group_by: group });
};
$("ad-send").onclick = function () {
var q = json("ad-query"), b = json("ad-body");
if (!q || !b) return;
var ids = $("ad-ids").value.split(",").map(function (s) { return s.trim(); }).filter(Boolean);
post("/ai/anthropic/admin/call", { call: $("ad-call").value, ids: ids, query: q, body: b, confirm: $("ad-confirm").checked });
};
})();