feat: surface codex app server governance summaries

local-agent/codex-app-server-runner.mjs

@@ -1287,6 +1287,68 @@ function normalizeDiscoveryMcpServers(result) {
     .filter(Boolean);
 }
 
+function normalizeDiscoveryAccountSummary(result) {
+  const account = result?.account && typeof result.account === "object" ? result.account : null;
+  const authMode = trimToDefined(account?.type) || trimToDefined(result?.authMode) || "none";
+  return {
+    signedIn: Boolean(account),
+    authMode,
+    planType: safeProgressText(account?.planType ?? result?.planType, 64) || "",
+    requiresOpenaiAuth: Boolean(result?.requiresOpenaiAuth),
+  };
+}
+
+function normalizeDiscoveryRateLimitSummary(result) {
+  const buckets = Object.values(
+    result?.rateLimitsByLimitId && typeof result.rateLimitsByLimitId === "object"
+      ? result.rateLimitsByLimitId
+      : {},
+  );
+  const rateLimits = buckets.length > 0 ? buckets : result?.rateLimits ? [result.rateLimits] : [];
+  const usedPercents = rateLimits
+    .map((bucket) => Number(bucket?.primary?.usedPercent))
+    .filter((value) => Number.isFinite(value))
+    .map((value) => Math.max(0, Math.min(100, Math.round(value))));
+  const reached = rateLimits.some((bucket) => Boolean(trimToDefined(bucket?.rateLimitReachedType)));
+  return {
+    bucketCount: rateLimits.length,
+    maxUsedPercent: usedPercents.length > 0 ? Math.max(...usedPercents) : 0,
+    reached,
+  };
+}
+
+function normalizeDiscoveryAppConfigSummary(result) {
+  const apps = result?.config?.apps && typeof result.config.apps === "object" ? result.config.apps : {};
+  const defaultConfig = apps._default && typeof apps._default === "object" ? apps._default : {};
+  const appEntries = Object.entries(apps).filter(([key]) => key !== "_default");
+  return {
+    appCount: appEntries.length,
+    enabledAppCount: appEntries.filter(([, value]) => value && typeof value === "object" && value.enabled === true)
+      .length,
+    defaultEnabled: defaultConfig.enabled !== false,
+    destructiveEnabled: Boolean(defaultConfig.destructive_enabled),
+    openWorldEnabled: Boolean(defaultConfig.open_world_enabled),
+  };
+}
+
+function normalizeDiscoveryConfigRequirements(result) {
+  return {
+    managed: Boolean(result?.managed),
+    requirementCount: asArray(result?.requirements).length,
+    warningCount: asArray(result?.warnings).length,
+  };
+}
+
+function normalizeDiscoveryExternalAgentMigration(result) {
+  const items = asArray(result?.items);
+  return {
+    itemCount: items.length,
+    homeItemCount: items.filter((item) => item?.cwd === null).length,
+    projectItemCount: items.filter((item) => trimToDefined(item?.cwd)).length,
+    itemTypes: Array.from(new Set(items.map((item) => trimToDefined(item?.itemType)).filter(Boolean))).sort(),
+  };
+}
+
 async function withCodexAppServerRpcSession(runnerConfig, callback) {
   const cwd = runnerConfig.cwd || process.cwd();
   let closed = false;
@@ -1403,6 +1465,11 @@ export async function discoverCodexAppServerCapabilities(runnerConfig) {
       collaborationModesResult,
       permissionProfilesResult,
       mcpServersResult,
+      accountResult,
+      rateLimitsResult,
+      configResult,
+      configRequirementsResult,
+      externalAgentConfigResult,
     ] = await Promise.all([
       safeRequest(request, "model/list", { includeHidden: false, limit }),
       safeRequest(request, "modelProvider/capabilities/read", {}),
@@ -1413,6 +1480,11 @@ export async function discoverCodexAppServerCapabilities(runnerConfig) {
       safeRequest(request, "collaborationMode/list", {}),
       safeRequest(request, "permissionProfile/list", { cwd, limit }),
       safeRequest(request, "mcpServerStatus/list", { limit, detail: "toolsAndAuthOnly" }),
+      safeRequest(request, "account/read", { refreshToken: false }),
+      safeRequest(request, "account/rateLimits/read"),
+      safeRequest(request, "config/read", { includeLayers: false }),
+      safeRequest(request, "configRequirements/read"),
+      safeRequest(request, "externalAgentConfig/detect", { includeHome: true, cwds: [cwd] }),
     ]);
 
     const models = asArray(modelResult?.data)
@@ -1441,6 +1513,11 @@ export async function discoverCodexAppServerCapabilities(runnerConfig) {
       collaborationModes: normalizeDiscoveryCollaborationModes(collaborationModesResult).slice(0, limit),
       permissionProfiles: normalizeDiscoveryPermissionProfiles(permissionProfilesResult).slice(0, limit),
       mcpServers: normalizeDiscoveryMcpServers(mcpServersResult).slice(0, limit),
+      accountSummary: normalizeDiscoveryAccountSummary(accountResult),
+      rateLimitSummary: normalizeDiscoveryRateLimitSummary(rateLimitsResult),
+      appConfigSummary: normalizeDiscoveryAppConfigSummary(configResult),
+      configRequirements: normalizeDiscoveryConfigRequirements(configRequirementsResult),
+      externalAgentMigration: normalizeDiscoveryExternalAgentMigration(externalAgentConfigResult),
       errors: [
         modelResult?.__bossError ? `model/list:${safeRuntimeDiagnosticText(modelResult.__bossError)}` : undefined,
         providerCapabilities?.__bossError
@@ -1461,6 +1538,17 @@ export async function discoverCodexAppServerCapabilities(runnerConfig) {
         mcpServersResult?.__bossError
           ? `mcpServerStatus/list:${safeRuntimeDiagnosticText(mcpServersResult.__bossError)}`
           : undefined,
+        accountResult?.__bossError ? `account/read:${safeRuntimeDiagnosticText(accountResult.__bossError)}` : undefined,
+        rateLimitsResult?.__bossError
+          ? `account/rateLimits/read:${safeRuntimeDiagnosticText(rateLimitsResult.__bossError)}`
+          : undefined,
+        configResult?.__bossError ? `config/read:${safeRuntimeDiagnosticText(configResult.__bossError)}` : undefined,
+        configRequirementsResult?.__bossError
+          ? `configRequirements/read:${safeRuntimeDiagnosticText(configRequirementsResult.__bossError)}`
+          : undefined,
+        externalAgentConfigResult?.__bossError
+          ? `externalAgentConfig/detect:${safeRuntimeDiagnosticText(externalAgentConfigResult.__bossError)}`
+          : undefined,
       ].filter(Boolean),
     };
   });