Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

Load admin credentials independently of usage history (#1374)

Regan Bell7b25c1ba662c
diff --git a/docs/screenshots/credentials/error.png b/docs/screenshots/credentials/error.png
new file mode 100644
index 000000000..5fc46ef42
Binary files /dev/null and b/docs/screenshots/credentials/error.png differ
diff --git a/docs/screenshots/credentials/loading.png b/docs/screenshots/credentials/loading.png
new file mode 100644
index 000000000..11a841dd8
Binary files /dev/null and b/docs/screenshots/credentials/loading.png differ
diff --git a/docs/screenshots/credentials/usage-loading.png b/docs/screenshots/credentials/usage-loading.png
new file mode 100644
index 000000000..c2b6592e5
Binary files /dev/null and b/docs/screenshots/credentials/usage-loading.png differ
diff --git a/plugins/admin/public/index.html b/plugins/admin/public/index.html
index 322c62536..9111a8c8f 100644
--- a/plugins/admin/public/index.html
+++ b/plugins/admin/public/index.html
@@ -7320,7 +7320,9 @@
saving.
</p>
</div>
- <div class="body"><div id="sc-list" class="hint">No credentials configured.</div></div>
+ <div class="body">
+ <div id="sc-list" class="hint" role="status" aria-live="polite">Loading credentials…</div>
+ </div>
<div
class="body hidden"
id="sc-editor"
@@ -8075,17 +8077,21 @@
const API_BASE = "__ADMIN_BASE__";
async function api(method, path, body) {
- const res = await fetch(API_BASE + path, {
- method,
- headers: body ? { "content-type": "application/json" } : {},
- ...(body ? { body: JSON.stringify(body) } : {}),
- });
- const text = await res.text();
- let data = null;
try {
- data = text ? JSON.parse(text) : null;
- } catch {}
- return { ok: res.ok, status: res.status, data };
+ const res = await fetch(API_BASE + path, {
+ method,
+ headers: body ? { "content-type": "application/json" } : {},
+ ...(body ? { body: JSON.stringify(body) } : {}),
+ });
+ const text = await res.text();
+ let data = null;
+ try {
+ data = text ? JSON.parse(text) : null;
+ } catch {}
+ return { ok: res.ok, status: res.status, data };
+ } catch {
+ return { ok: false, status: 0, data: { message: "Network request failed." } };
+ }
}
async function openWebUiAs(target) {
@@ -9589,12 +9595,24 @@
const requestedView = view;
const requestId = ++governanceReq;
const scopeChanged = scope !== loadedGovernanceScope;
+ if (requestedView === "credentials") {
+ serviceCredList = [];
+ setServiceCredentialState("Loading credentials…");
+ $("sc-add").disabled = true;
+ void loadPersonalKeychainSummary(requestId, requestedScope);
+ }
const r = await api(
"GET",
"/api/scopes/" + encodeURIComponent(scope) + "?view=" + encodeURIComponent(requestedView),
);
if (requestId !== governanceReq || requestedScope !== scope || requestedView !== view) return;
if (!r.ok) {
+ if (requestedView === "credentials") {
+ setServiceCredentialState(
+ r.status === 403 ? "You don't administer this scope." : "Could not load credentials.",
+ true,
+ );
+ }
setStatus(
"st-policy",
r.status === 403 ? "You don't administer this scope." : r.data?.message || "Failed to load.",
@@ -10074,7 +10092,10 @@
if (showFeatureFlags) renderFeatureFlags(r.data.featureFlags || []);
renderServiceCreds(r.data.serviceCredentials || []);
if (view === "models") void loadCustomProviders();
- if (view === "credentials") void loadPersonalKeychainSummary();
+ if (view === "credentials") {
+ $("sc-add").disabled = false;
+ void loadServiceCredentialUsage(requestedScope, requestId);
+ }
if (scopeChanged) resetScForm();
loadedGovernanceScope = scope;
initCustomDropdowns($("view-governance"));
@@ -10127,11 +10148,15 @@
return true;
}
async function refreshServiceCredentialConflict() {
+ const requestedScope = scope;
+ const requestedView = view;
+ const requestId = ++governanceReq;
const fresh = await api(
"GET",
"/api/scopes/" + encodeURIComponent(scope) + "?view=" + encodeURIComponent(view),
);
- if (!fresh.ok) return false;
+ if (requestId !== governanceReq || requestedScope !== scope || requestedView !== view || !fresh.ok)
+ return false;
serviceCredDirectory = fresh.data.directoryMembers || [];
serviceCredChannels = fresh.data.directoryChannels || [];
const options = $("sc-people-options");
@@ -10146,6 +10171,7 @@
const refreshedEditing = credentials.find((credential) => credential.slug === scEditing);
if (refreshedEditing) scEditVersion = refreshedEditing.updatedAt;
renderServiceCreds(credentials);
+ void loadServiceCredentialUsage(requestedScope, requestId);
renderServiceCredentialCapability();
updateScFormDirty();
return refreshedEditing ? "present" : "missing";
@@ -10206,6 +10232,42 @@
let scSnapshot = "";
let serviceCredList = [];
let serviceCredentialResolutionError = "";
+ function setServiceCredentialState(message, retry = false) {
+ const root = $("sc-list");
+ root.className = "hint";
+ root.textContent = message;
+ if (retry) {
+ const button = document.createElement("button");
+ button.type = "button";
+ button.textContent = "Retry";
+ button.style.marginInlineStart = "8px";
+ button.onclick = () => loadScope();
+ root.appendChild(button);
+ }
+ }
+ async function loadServiceCredentialUsage(requestedScope, requestId) {
+ if (!serviceCredList.length) return;
+ const result = await api("GET", "/api/scopes/" + encodeURIComponent(requestedScope) + "/credential-usage");
+ if (requestId !== governanceReq || requestedScope !== scope || view !== "credentials") return;
+ const summaries = new Map((result.data?.summaries || []).map((summary) => [summary.slug, summary]));
+ renderServiceCreds(
+ serviceCredList.map((credential) => ({
+ ...credential,
+ ...(result.ok ? summaries.get(credential.slug) : {}),
+ usageUnavailable: !result.ok || !summaries.has(credential.slug),
+ })),
+ );
+ }
+ function serviceCredentialUsageLabel(credential) {
+ if (credential.usageUnavailable) return "Usage unavailable";
+ if (credential.usageCount == null) return "Loading usage…";
+ const window = credential.usageCount
+ ? " since " + fmtTime(credential.usageSince)
+ : " in retained broker history";
+ return (
+ (credential.usageTruncated ? "at least " : "") + plural(credential.usageCount, "successful use") + window
+ );
+ }
function renderServiceCreds(list) {
serviceCredList = list;
const root = $("sc-list");
@@ -10234,17 +10296,11 @@
const who = orgWide ? "Organization-wide" : plural((c.grantees || []).length, "principal");
const meta = document.createElement("div");
meta.className = "hint";
- const usageWindow = c.usageCount ? " since " + fmtTime(c.usageSince) : " in retained broker history";
const target =
c.delivery === "env"
? "sandbox env $" + (c.envKey || "?")
: c.host + " · " + (c.allowedMethods && c.allowedMethods.length ? c.allowedMethods.join("/") : "GET");
- meta.textContent =
- target +
- " · " +
- (c.usageTruncated ? "at least " : "") +
- plural(c.usageCount || 0, "successful use") +
- usageWindow;
+ meta.textContent = target + " · " + serviceCredentialUsageLabel(c);
const badges = document.createElement("div");
badges.className = "credential-badges";
badges.append(
@@ -10682,11 +10738,14 @@
const principals = c.grantees.some((g) => g.startsWith("org:"))
? "everyone in the organization"
: c.grantees.map(serviceCredentialPrincipalLabel).join(", ");
- const recent = c.recentUsagePrincipals.length
- ? " Recent users in the retained window: " +
- c.recentUsagePrincipals.map((id) => serviceCredentialPrincipalLabel("personal:" + id)).join(", ") +
- "."
- : " No successful use appears in the retained window.";
+ const recent =
+ c.usageCount == null || c.usageUnavailable
+ ? " Recent usage is unavailable."
+ : c.recentUsagePrincipals.length
+ ? " Recent users in the retained window: " +
+ c.recentUsagePrincipals.map((id) => serviceCredentialPrincipalLabel("personal:" + id)).join(", ") +
+ "."
+ : " No successful use appears in the retained window.";
const confirmed = await reviewGovernanceChange({
title: "Delete “" + (c.name || c.slug) + "”?",
subtitle: "This credential currently grants broker access to " + principals + "." + recent,
@@ -11358,8 +11417,11 @@
rows.appendChild(tr);
});
}
- async function loadPersonalKeychainSummary() {
+ async function loadPersonalKeychainSummary(requestId, requestedScope) {
+ $("keychain-user-count").textContent = "—";
+ $("keychain-standing-count").textContent = "—";
const res = await api("GET", "/api/keychain?summary=1");
+ if (requestId !== governanceReq || requestedScope !== scope || view !== "credentials") return;
$("keychain-user-count").textContent = res.ok && res.data?.enabled !== false ? String(res.data.users) : "—";
$("keychain-standing-count").textContent =
res.ok && res.data?.enabled !== false ? String(res.data.standing) : "—";
diff --git a/plugins/admin/src/index.ts b/plugins/admin/src/index.ts
index e6a75953c..cc1ed2640 100644
--- a/plugins/admin/src/index.ts
+++ b/plugins/admin/src/index.ts
@@ -416,14 +416,15 @@ async function handle(req: IncomingMessage, res: ServerResponse): Promise<void>
if (!principal) return json(res, 401, { error: "signed_out" });
const rest = pathname.slice("/api/scopes/".length);
if (method === "GET") {
- if (rest.endsWith("/export")) {
- const scopeId = decodeURIComponent(rest.slice(0, -"/export".length));
+ const suffix = ["/export", "/credential-usage"].find((suffix) => rest.endsWith(suffix));
+ if (suffix) {
+ const scopeId = decodeURIComponent(rest.slice(0, -suffix.length));
return forward(
req,
res,
principal,
"GET",
- `/v1/admin/scopes/${encodeURIComponent(scopeId)}/export${url.search}`,
+ `/v1/admin/scopes/${encodeURIComponent(scopeId)}${suffix}${url.search}`,
);
}
const scopeId = decodeURIComponent(rest);
diff --git a/plugins/admin/test/default-view.test.ts b/plugins/admin/test/default-view.test.ts
index 2e47fbab0..a3f5c0526 100644
--- a/plugins/admin/test/default-view.test.ts
+++ b/plugins/admin/test/default-view.test.ts
@@ -487,7 +487,7 @@ test("admin parity views expose the requested card groups and real navigation ac
assert.match(html, /id="model-custom-provider-rows"/);
assert.match(html, /provider\.models\.length/);
assert.match(html, /function renderBuiltInConnectors\(\)/);
- assert.match(html, /function loadPersonalKeychainSummary\(\)/);
+ assert.match(html, /function loadPersonalKeychainSummary\(requestId, requestedScope\)/);
assert.doesNotMatch(html, /Enabled harnesses/);
assert.doesNotMatch(html, /id="card-browsing"/);
assert.doesNotMatch(html, /\$\("feature-flag-enable"\)\.disabled = true/);
diff --git a/plugins/admin/test/grants.test.ts b/plugins/admin/test/grants.test.ts
index fb5566ab6..da4e22100 100644
--- a/plugins/admin/test/grants.test.ts
+++ b/plugins/admin/test/grants.test.ts
@@ -135,3 +135,12 @@ test("grants/users require a signed-in cookie → 401 when absent (no core hop)"
assert.equal((await fetch(`${base}/api/keychain`)).status, 401);
assert.equal(calls.length, before, "a signed-out request is rejected at the surface, never forwarded");
});
+
+test("GET credential usage forwards the scoped path with signed admin identity", async () => {
+ const response = await fetch(`${base}/api/scopes/org%3Aacme/credential-usage`, { headers: { cookie: ADMIN } });
+ assert.equal(response.status, 200);
+ const call = calls.at(-1)!;
+ assert.equal(call.url, "/v1/admin/scopes/org%3Aacme/credential-usage");
+ assert.equal(call.actor, "U-admin@acme");
+ assert.equal(call.signed, true);
+});
diff --git a/plugins/admin/test/settings-load.test.ts b/plugins/admin/test/settings-load.test.ts
index 0d8dbeb76..ba174cb60 100644
--- a/plugins/admin/test/settings-load.test.ts
+++ b/plugins/admin/test/settings-load.test.ts
@@ -125,3 +125,98 @@ test("branding reload clears only the committed draft and preserves other unsave
assert.equal(reloads, otherDraft ? 0 : 1);
}
});
+
+test("credential usage distinguishes loading, failure, and confirmed zero", () => {
+ const context = vm.createContext({ plural: (n: number, word: string) => `${n} ${word}s`, fmtTime: String });
+ vm.runInContext(extract("function serviceCredentialUsageLabel(", "function renderServiceCreds("), context);
+ assert.equal(vm.runInContext("serviceCredentialUsageLabel({})", context), "Loading usage…");
+ assert.equal(vm.runInContext("serviceCredentialUsageLabel({usageUnavailable:true})", context), "Usage unavailable");
+ assert.equal(
+ vm.runInContext("serviceCredentialUsageLabel({usageCount:0})", context),
+ "0 successful uses in retained broker history",
+ );
+});
+
+test("usage completion preserves credentials on failure and ignores stale scope, view, and reload responses", async () => {
+ for (const state of ["current", "failed", "scope", "view", "reload"]) {
+ const pending = Promise.withResolvers<unknown>();
+ let renders = 0;
+ const context = vm.createContext({
+ scope: "org:example",
+ view: "credentials",
+ governanceReq: 1,
+ serviceCredList: [{ slug: "example", name: "Example", grantees: ["org:example"] }],
+ api: () => pending.promise,
+ renderServiceCreds: (list: unknown) => {
+ renders++;
+ context.serviceCredList = list;
+ },
+ });
+ vm.runInContext(
+ extract("async function loadServiceCredentialUsage(", "function serviceCredentialUsageLabel("),
+ context,
+ );
+ const work = vm.runInContext('loadServiceCredentialUsage("org:example", 1)', context);
+ if (state === "scope") context.scope = "org:other";
+ if (state === "view") context.view = "models";
+ if (state === "reload") context.governanceReq = 2;
+ pending.resolve(
+ state === "failed" ? { ok: false } : { ok: true, data: { summaries: [{ slug: "example", usageCount: 7 }] } },
+ );
+ await work;
+ assert.equal(renders, ["current", "failed"].includes(state) ? 1 : 0, state);
+ assert.equal(context.serviceCredList[0].name, "Example");
+ assert.equal(context.serviceCredList[0].usageCount, state === "current" ? 7 : undefined);
+ assert.equal(
+ context.serviceCredList[0].usageUnavailable,
+ ({ failed: true, current: false } as Record<string, boolean>)[state],
+ );
+ }
+});
+
+test("credential request displays loading, then a visible retry on failure", async () => {
+ const pending = Promise.withResolvers<unknown>();
+ const messages: unknown[] = [];
+ const add = { disabled: false };
+ const context = vm.createContext({
+ scope: "org:example",
+ view: "credentials",
+ governanceReq: 0,
+ loadedGovernanceScope: null,
+ serviceCredList: [{ slug: "stale" }],
+ setServiceCredentialState: (...args: unknown[]) => messages.push(args),
+ $: () => add,
+ loadPersonalKeychainSummary() {},
+ setStatus() {},
+ api: () => pending.promise,
+ });
+ const source = extract("async function loadScope() {", " const refreshModelChoices = [];");
+ vm.runInContext(source + "}", context);
+ const work = vm.runInContext("loadScope()", context);
+ assert.deepEqual(messages, [["Loading credentials…"]]);
+ assert.equal(add.disabled, true);
+ assert.equal(context.serviceCredList.length, 0);
+ pending.resolve({ ok: false, status: 500 });
+ await work;
+ assert.deepEqual(messages.at(-1), ["Could not load credentials.", true]);
+});
+
+test("admin requests convert rejected fetches and interrupted bodies into failure states", async () => {
+ for (const fetch of [
+ async () => {
+ throw new Error("network disconnected");
+ },
+ async () => ({
+ text: async () => {
+ throw new Error("body interrupted");
+ },
+ }),
+ ]) {
+ const context = vm.createContext({ fetch, API_BASE: "" });
+ vm.runInContext(extract("async function api(", "async function openWebUiAs("), context);
+ const result = await vm.runInContext('api("GET", "/api/scopes/org:example")', context);
+ assert.equal(result.ok, false);
+ assert.equal(result.status, 0);
+ assert.equal(result.data.message, "Network request failed.");
+ }
+});
diff --git a/scripts/service-credential-livetest.ts b/scripts/service-credential-livetest.ts
index b41851d18..56379dbc5 100644
--- a/scripts/service-credential-livetest.ts
+++ b/scripts/service-credential-livetest.ts
@@ -78,7 +78,7 @@ async function main(): Promise<void> {
check(
"GET projects the credential (hasSecret, no material)",
!!cred && cred.hasSecret === true && !cfg1.raw.includes(FAKE_SECRET),
- cred ? `grantees=${JSON.stringify(cred.grantees)} usage=${cred.usageCount}` : "not found",
+ cred ? `grantees=${JSON.stringify(cred.grantees)}` : "not found",
);
check("default sharing is org-wide", !!cred && Array.isArray(cred.grantees) && cred.grantees.includes(`org:${ORG}`));
@@ -125,8 +125,13 @@ async function main(): Promise<void> {
`${notEntitled.status} ${notEntitled.json?.error}`,
);
- const cfg2 = await admin("GET", `/v1/admin/scopes/org:${ORG}`);
- const used = cfg2.json?.serviceCredentials?.find((c: any) => c.slug === SLUG)?.usageCount;
+ let used: number | undefined;
+ for (let attempt = 0; attempt < 20; attempt++) {
+ const usage = await admin("GET", `/v1/admin/scopes/org:${ORG}/credential-usage`);
+ used = usage.json?.summaries?.find((c: any) => c.slug === SLUG)?.usageCount;
+ if (used === 1) break;
+ await new Promise((resolve) => setTimeout(resolve, 100));
+ }
check("usage count incremented by the one successful call", used === 1, `usageCount=${used}`);
await admin("PUT", `/v1/admin/scopes/org:${ORG}/service-credentials`, {
diff --git a/src/admin/credential-usage-sink.ts b/src/admin/credential-usage-sink.ts
index c75a1d396..679f42cee 100644
--- a/src/admin/credential-usage-sink.ts
+++ b/src/admin/credential-usage-sink.ts
@@ -18,15 +18,46 @@ interface CredentialUsageQuery {
limit?: number;
}
+export const CREDENTIAL_USAGE_WINDOW = 5000;
+
+interface CredentialUsageSummary {
+ slug: string;
+ usageCount: number;
+ usageTruncated: boolean;
+ usageSince: number | null;
+ lastUsedAt: number | null;
+ recentUsagePrincipals: string[];
+}
+
export interface CredentialUsageSink {
record(s: Omit<CredentialUsageSample, "ts">): void;
list(opts?: CredentialUsageQuery): Promise<CredentialUsageSample[]>;
+ summary(slugs: readonly string[]): Promise<CredentialUsageSummary[]>;
}
export function createCredentialUsageSink(): CredentialUsageSink {
- return createTimestampedEventSink<CredentialUsageSample>({
+ const sink = createTimestampedEventSink<CredentialUsageSample>({
max: 10000,
- defaultLimit: 5000,
+ defaultLimit: CREDENTIAL_USAGE_WINDOW,
equalityFields: ["slug"],
});
+ return {
+ ...sink,
+ async summary(slugs) {
+ return Promise.all(
+ [...new Set(slugs)].map(async (slug) => {
+ const recent = await sink.list({ slug, limit: CREDENTIAL_USAGE_WINDOW });
+ const successful = recent.filter((event) => event.status === "ok");
+ return {
+ slug,
+ usageCount: successful.length,
+ usageTruncated: recent.length === CREDENTIAL_USAGE_WINDOW,
+ usageSince: successful.length ? Math.min(...successful.map((event) => event.ts)) : null,
+ lastUsedAt: successful.length ? Math.max(...successful.map((event) => event.ts)) : null,
+ recentUsagePrincipals: [...new Set(successful.map((event) => event.principalId))].slice(0, 12),
+ };
+ }),
+ );
+ },
+ };
}
diff --git a/src/admin/postgres-credential-usage-sink.ts b/src/admin/postgres-credential-usage-sink.ts
index 561e1a92c..67b6e199f 100644
--- a/src/admin/postgres-credential-usage-sink.ts
+++ b/src/admin/postgres-credential-usage-sink.ts
@@ -1,5 +1,9 @@
import { createPostgresEventSink, type EventColumn } from "./scoped-event-sink.ts";
-import type { CredentialUsageSample, CredentialUsageSink } from "./credential-usage-sink.ts";
+import {
+ CREDENTIAL_USAGE_WINDOW,
+ type CredentialUsageSample,
+ type CredentialUsageSink,
+} from "./credential-usage-sink.ts";
const COLUMNS: readonly EventColumn<keyof CredentialUsageSample & string>[] = [
["ts", "ts", "BIGINT", "number", true],
@@ -12,7 +16,7 @@ const COLUMNS: readonly EventColumn<keyof CredentialUsageSample & string>[] = [
];
export function createPostgresCredentialUsageSink(connectionString: string): CredentialUsageSink {
- return createPostgresEventSink<CredentialUsageSample>({
+ const sink = createPostgresEventSink<CredentialUsageSample>({
connectionString,
table: "credential_usage",
columns: COLUMNS,
@@ -28,8 +32,42 @@ export function createPostgresCredentialUsageSink(connectionString: string): Cre
},
],
},
- defaultLimit: 5000,
+ defaultLimit: CREDENTIAL_USAGE_WINDOW,
equalityFilters: { scopeId: "scope_label", slug: "slug" },
persistErrorMessage: "[credential-usage] failed to persist broker call:",
});
+ return {
+ ...sink,
+ async summary(slugs) {
+ if (!slugs.length) return [];
+ const rows = await sink.q(
+ `SELECT requested.slug, summary.*
+ FROM unnest($1::text[]) AS requested(slug)
+ CROSS JOIN LATERAL (
+ WITH recent AS (
+ SELECT id, ts, status, principal_id FROM credential_usage
+ WHERE slug = requested.slug ORDER BY ts DESC, id DESC LIMIT $2
+ )
+ SELECT count(*) FILTER (WHERE status = 'ok') AS usage_count,
+ count(*) = $2 AS usage_truncated,
+ min(ts) FILTER (WHERE status = 'ok') AS usage_since,
+ max(ts) FILTER (WHERE status = 'ok') AS last_used_at,
+ ARRAY(SELECT principal_id FROM (
+ SELECT DISTINCT ON (principal_id) principal_id, ts, id FROM recent WHERE status = 'ok'
+ ORDER BY principal_id, ts DESC, id DESC
+ ) AS latest ORDER BY ts DESC, id DESC LIMIT 12) AS principals
+ FROM recent
+ ) AS summary`,
+ [[...new Set(slugs)], CREDENTIAL_USAGE_WINDOW],
+ );
+ return rows.map((row) => ({
+ slug: String(row.slug),
+ usageCount: Number(row.usage_count),
+ usageTruncated: Boolean(row.usage_truncated),
+ usageSince: row.usage_since == null ? null : Number(row.usage_since),
+ lastUsedAt: row.last_used_at == null ? null : Number(row.last_used_at),
+ recentUsagePrincipals: row.principals as string[],
+ }));
+ },
+ };
}
diff --git a/src/api/routes/admin.ts b/src/api/routes/admin.ts
index dcc64a3c8..df4628b18 100644
--- a/src/api/routes/admin.ts
+++ b/src/api/routes/admin.ts
@@ -3,6 +3,7 @@ import { type ApiCtx, type Route } from "./route.ts";
import {
getAdminResources,
getScopeConfig,
+ getCredentialUsageSummary,
listAdminScopes,
putScopeConfig,
retention,
@@ -98,6 +99,12 @@ const routes: ReadonlyArray<Route<ApiCtx>> = [
{ method: "GET", path: "/v1/admin/whoami", auth: "either", handle: whoami },
{ method: "GET", path: "/v1/admin/scopes", auth: "either", handle: listAdminScopes },
{ method: "GET", path: "/v1/admin/scopes/:scope", auth: "either", handle: getScopeConfig },
+ {
+ method: "GET",
+ path: "/v1/admin/scopes/:scope/credential-usage",
+ auth: "either",
+ handle: getCredentialUsageSummary,
+ },
{ method: "GET", path: "/v1/admin/resources", auth: "either", handle: getAdminResources },
{ method: "GET", path: "/v1/admin/retention", auth: "either", handle: retention },
{ method: "GET", path: "/v1/admin/metrics", auth: "either", handle: metrics },
diff --git a/src/api/routes/admin/scope-config.ts b/src/api/routes/admin/scope-config.ts
index 7affaaa9b..62c8085e2 100644
--- a/src/api/routes/admin/scope-config.ts
+++ b/src/api/routes/admin/scope-config.ts
@@ -282,24 +282,31 @@ const SETTINGS_RESOURCES = {
type SettingsView = keyof typeof SETTINGS_RESOURCES;
async function scopeServiceCredentials(deps: ApiCtx["deps"], targetScope: string) {
- return Promise.all(
- (deps.serviceCreds ? await deps.serviceCreds.listServiceCredentials(targetScope) : []).map(async (c) => {
- const [usage, grants] = await Promise.all([
- deps.credentialUsage?.list({ slug: c.slug, limit: 5000 }) ?? [],
- deps.acl?.grantsFor(targetScope, encodeRef(serviceCredRef(c.slug))) ?? [],
- ]);
- const successful = usage.filter((u) => u.status === "ok");
- return {
- ...c,
- grantees: grants.map((g) => g.granteeScopeId),
- usageCount: successful.length,
- usageTruncated: usage.length === 5000,
- usageSince: successful.length ? Math.min(...successful.map((u) => u.ts)) : null,
- lastUsedAt: successful.length ? Math.max(...successful.map((u) => u.ts)) : null,
- recentUsagePrincipals: [...new Set(successful.map((u) => u.principalId))].slice(0, 12),
- };
- }),
- );
+ const [credentials, grants] = await Promise.all([
+ deps.serviceCreds?.listServiceCredentials(targetScope) ?? [],
+ deps.acl?.list() ?? [],
+ ]);
+ const grantees = new Map<string, string[]>();
+ for (const grant of grants) {
+ if (grant.ownerScopeId !== targetScope) continue;
+ const scopes = grantees.get(grant.ref) ?? [];
+ scopes.push(grant.granteeScopeId);
+ grantees.set(grant.ref, scopes);
+ }
+ return credentials.map((credential) => ({
+ ...credential,
+ grantees: grantees.get(encodeRef(serviceCredRef(credential.slug))) ?? [],
+ }));
+}
+
+export async function getCredentialUsageSummary(ctx: ApiCtx): Promise<void> {
+ const targetScope = ctx.params.scope!;
+ if (!targetScope || targetScope.includes("/")) return sendJson(ctx.res, 404, { error: "not_found" });
+ if (!(await authorizeAdmin(ctx, targetScope))) return;
+ const credentials = (await ctx.deps.serviceCreds?.listServiceCredentials(targetScope)) ?? [];
+ if (!ctx.deps.credentialUsage) return sendJson(ctx.res, 503, { error: "usage_unavailable" });
+ const summaries = await ctx.deps.credentialUsage.summary(credentials.map((credential) => credential.slug));
+ return sendJson(ctx.res, 200, { summaries });
}
async function scopeEgress(deps: ApiCtx["deps"], targetScope: string) {
diff --git a/test/postgres-credential-usage-sink.test.ts b/test/postgres-credential-usage-sink.test.ts
index 74ade8a93..2cc15534a 100644
--- a/test/postgres-credential-usage-sink.test.ts
+++ b/test/postgres-credential-usage-sink.test.ts
@@ -92,3 +92,80 @@ test("pg credential-usage sink: sparse and absent credentials use an ordered ind
await p.end();
}
});
+
+test("pg credential summaries aggregate a bounded window without transferring raw events", { skip }, async (t) => {
+ const { createCredentialUsageSink, CREDENTIAL_USAGE_WINDOW } = await import("../src/admin/credential-usage-sink.ts");
+ const memory = createCredentialUsageSink();
+ const sink = createPostgresCredentialUsageSink(URL!);
+ const pg = (await import("pg")).default;
+ const pool = new pg.Pool({ connectionString: URL });
+ t.after(() => pool.end());
+ await pool.query(
+ `INSERT INTO credential_usage(ts, slug, host, status, scope_label, principal_id)
+ SELECT n, 'summary-window', 'example.com', CASE WHEN n % 3 = 0 THEN 'denied' ELSE 'ok' END,
+ 'personal:summary', 'person-' || (n % 20) FROM generate_series(1, $1::int) n`,
+ [CREDENTIAL_USAGE_WINDOW + 10],
+ );
+ const clock = t.mock.method(Date, "now");
+ for (let n = 1; n <= CREDENTIAL_USAGE_WINDOW + 10; n++) {
+ clock.mock.mockImplementation(() => n);
+ memory.record({
+ slug: "summary-window",
+ host: "example.com",
+ status: n % 3 === 0 ? "denied" : "ok",
+ scopeLabel: "personal:summary",
+ principalId: "person-" + (n % 20),
+ });
+ }
+ clock.mock.restore();
+ const slugs = ["summary-window", "summary-absent", "summary-window"];
+ assert.deepEqual(await sink.summary(slugs), await memory.summary(slugs));
+ await pool.query(`INSERT INTO credential_usage(ts, slug, host, status, scope_label, principal_id)
+ SELECT 123, 'summary-ties', 'example.com', 'ok', 'personal:summary', 'person-' || n
+ FROM generate_series(1, 20) n`);
+ const tiedClock = t.mock.method(Date, "now", () => 123);
+ for (let n = 1; n <= 20; n++) {
+ memory.record({
+ slug: "summary-ties",
+ host: "example.com",
+ status: "ok",
+ scopeLabel: "personal:summary",
+ principalId: "person-" + n,
+ });
+ }
+ tiedClock.mock.restore();
+ assert.deepEqual(await sink.summary(["summary-ties"]), await memory.summary(["summary-ties"]));
+ assert.deepEqual(await sink.summary([]), []);
+ assert.equal((await sink.summary(["serp"]))[0]!.usageCount, 0);
+});
+
+test("pg credential summaries do not wait for pending telemetry writes", { skip }, async (t) => {
+ const pg = (await import("pg")).default;
+ const pool = new pg.Pool({ connectionString: URL });
+ const locker = await pool.connect();
+ const sink = createPostgresCredentialUsageSink(URL!);
+ await sink.summary(["summary-blocked"]);
+ await locker.query("BEGIN");
+ await locker.query("LOCK TABLE credential_usage IN SHARE MODE");
+ t.after(async () => {
+ await locker.query("ROLLBACK");
+ locker.release();
+ await sink.list({ slug: "summary-blocked" });
+ await pool.end();
+ });
+ sink.record({
+ slug: "summary-blocked",
+ host: "example.com",
+ status: "ok",
+ scopeLabel: "personal:summary",
+ principalId: "summary",
+ });
+ const result = await Promise.race([
+ sink.summary(["summary-blocked"]),
+ new Promise<never>((_, reject) => {
+ const timer = setTimeout(() => reject(new Error("summary waited for blocked write")), 2000);
+ timer.unref();
+ }),
+ ]);
+ assert.equal(result[0]!.usageCount, 0);
+});
diff --git a/test/service-credential-route.test.ts b/test/service-credential-route.test.ts
index c53b646a1..d3b32b3d6 100644
--- a/test/service-credential-route.test.ts
+++ b/test/service-credential-route.test.ts
@@ -99,8 +99,6 @@ const getCfg = async (base: string) =>
hasSecret: boolean;
enabled: boolean;
grantees: string[];
- usageCount: number;
- usageTruncated: boolean;
updatedAt: number;
injection?: { header?: string; scheme?: string; actor?: boolean };
allowedMethods?: string[];
@@ -126,8 +124,7 @@ test("admin creates a credential (default org-wide); GET projects it WITHOUT the
assert.ok(cred);
assert.equal(cred!.hasSecret, true);
assert.deepEqual(cred!.grantees, ["org:default-org"]);
- assert.equal(cred!.usageCount, 0);
- assert.equal(cred!.usageTruncated, false);
+ assert.equal("usageCount" in cred, false);
assert.doesNotMatch(JSON.stringify(cfg), /super-secret-bearer/);
} finally {
await srv.close();
@@ -1232,3 +1229,73 @@ test("the published-apps switch defaults on, round-trips, survives a partial upd
await srv.close();
}
});
+
+test("credential lists batch grants and finish without usage reads", async (t) => {
+ const srv = start();
+ t.after(srv.close);
+ for (const slug of ["first", "second"]) {
+ assert.equal(
+ (await putCred(srv.base, { slug, name: slug, host: "api.example.com", secret: "private" })).status,
+ 200,
+ );
+ }
+ const listGrants = t.mock.method(srv.built.acl, "list");
+ t.mock.method(srv.built.acl, "grantsFor", () => {
+ throw new Error("per-credential grant read");
+ });
+ t.mock.method(srv.built.credentialUsage, "list", () => {
+ throw new Error("raw usage read");
+ });
+ t.mock.method(srv.built.credentialUsage, "summary", () => {
+ throw new Error("summary read on list path");
+ });
+ const response = await fetch(`${srv.base}/v1/admin/scopes/org:default-org?view=credentials`, {
+ headers: ADMIN,
+ signal: AbortSignal.timeout(500),
+ });
+ assert.equal(response.status, 200);
+ const body = (await response.json()) as { serviceCredentials: { grantees: string[]; usageCount?: number }[] };
+ assert.equal(body.serviceCredentials.length, 2);
+ assert.equal(listGrants.mock.callCount(), 1);
+ for (const credential of body.serviceCredentials) {
+ assert.deepEqual(credential.grantees, ["org:default-org"]);
+ assert.equal(credential.usageCount, undefined);
+ }
+});
+
+test("usage summaries authorize before reads and include only the requested scope's credentials", async (t) => {
+ const srv = start();
+ t.after(srv.close);
+ await putCred(srv.base, { slug: "summary", name: "Summary", host: "api.example.com", secret: "private" });
+ srv.built.credentialUsage.record({
+ slug: "summary",
+ host: "api.example.com",
+ status: "ok",
+ scopeLabel: "personal:U1",
+ principalId: "U1",
+ });
+ srv.built.credentialUsage.record({
+ slug: "unlisted",
+ host: "api.example.com",
+ status: "ok",
+ scopeLabel: "personal:U2",
+ principalId: "U2",
+ });
+ const read = t.mock.method(srv.built.serviceCreds, "listServiceCredentials");
+ const summarize = t.mock.method(srv.built.credentialUsage, "summary");
+ const path = `${srv.base}/v1/admin/scopes/org:default-org/credential-usage`;
+ assert.equal((await fetch(path, { headers: { "x-admin-actor": "nobody@default-org" } })).status, 403);
+ assert.equal(read.mock.callCount(), 0);
+ assert.equal(summarize.mock.callCount(), 0);
+ const response = await fetch(path, { headers: ADMIN });
+ assert.equal(response.status, 200);
+ const body = (await response.json()) as {
+ summaries: { slug: string; usageCount: number; recentUsagePrincipals: string[] }[];
+ };
+ assert.equal(body.summaries.length, 1);
+ assert.equal(body.summaries[0]!.slug, "summary");
+ assert.equal(body.summaries[0]!.usageCount, 1);
+ assert.deepEqual(body.summaries[0]!.recentUsagePrincipals, ["U1"]);
+ assert.deepEqual(summarize.mock.calls[0]!.arguments, [["summary"]]);
+ assert.doesNotMatch(JSON.stringify(body), /private|unlisted|U2/);
+});