axusage 3.5.0 → 3.7.0

package/README.md

@@ -112,12 +112,31 @@ Credential source config is read from:
 - Config file path shown in `axusage --help`
 - `AXUSAGE_SOURCES` environment variable (JSON), which overrides file config
 
+### Multi-Instance Configuration
+
+To monitor multiple accounts for the same service, use an array of instance configs:
+
+```json
+{
+  "claude": [
+    { "source": "vault", "name": "work", "displayName": "Claude (Work)" },
+    {
+      "source": "vault",
+      "name": "personal",
+      "displayName": "Claude (Personal)"
+    }
+  ]
+}
+```
+
+Each instance resolves credentials independently. Named credentials require vault to be configured (`AXVAULT` env). Single-instance configs can use string shorthand (`"auto"`, `"local"`, `"vault"`) or object form.
+
 ## Examples
 
 ### Extract service and utilization (TSV + awk)
 
 ```bash
-axusage --format tsv | tail -n +2 | awk -F'\t' '{print $1, $4"%"}'
+axusage --format tsv | tail -n +2 | awk -F'\t' '{print $1, $5"%"}'
 ```
 
 ### Count windows by service (TSV + cut/sort/uniq)
@@ -129,7 +148,7 @@ axusage --format tsv | tail -n +2 | cut -f1 | sort | uniq -c
 ### Filter by utilization threshold (TSV + awk)
 
 ```bash
-axusage --format tsv | tail -n +2 | awk -F'\t' '$4 > 50 {print $1, $3, $4"%"}'
+axusage --format tsv | tail -n +2 | awk -F'\t' '$5 > 50 {print $1, $4, $5"%"}'
 ```
 
 ### Extract utilization as JSON (JSON + jq)
@@ -180,7 +199,7 @@ AXUSAGE_PORT=9090 AXUSAGE_INTERVAL=60 axusage serve
 ### Endpoints
 
 - `GET /metrics` — Prometheus text exposition (`text/plain; version=0.0.4`). Serves cached data immediately; triggers a background refresh when stale. Returns 503 when all services are currently failing.
-- `GET /usage` — JSON array of usage objects (one per service). Waits for a fresh snapshot when stale. Returns 503 if no data is available. Date fields (e.g. `resetsAt`) are serialized as ISO 8601 strings.
+- `GET /usage` — JSON array of usage objects (one per service instance; multi-instance configs produce multiple entries per service type). Waits for a fresh snapshot when stale. Returns 503 if no data is available. Date fields (e.g. `resetsAt`) are serialized as ISO 8601 strings.
 - `GET /health` — JSON health status with version, last refresh time, tracked services, and errors. Always responds immediately from cached state without triggering a refresh.
 
 ### Container Deployment

package/dist/adapters/claude.d.ts

@@ -1,9 +1,2 @@
-import type { ServiceAdapter } from "../types/domain.js";
-/**
- * Claude service adapter using direct API access.
- *
- * This adapter uses the OAuth token from Claude Code's credential store
- * (Keychain on macOS, credentials file elsewhere) to make direct API calls
- * to the Anthropic usage endpoint.
- */
-export declare const claudeAdapter: ServiceAdapter;
+import type { ServiceUsageFetcher } from "../types/domain.js";
+export declare const claudeUsageFetcher: ServiceUsageFetcher;

package/dist/adapters/claude.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { ApiError } from "../types/domain.js";
-import { getServiceAccessToken } from "../services/get-service-access-token.js";
 import { UsageResponse as UsageResponseSchema } from "../types/usage.js";
 import { coalesceClaudeUsageResponse } from "./coalesce-claude-usage-response.js";
 import { toServiceUsageData } from "./parse-claude-usage.js";
@@ -33,64 +32,52 @@ async function fetchPlanType(accessToken) {
         return undefined;
     }
 }
-/**
- * Claude service adapter using direct API access.
- *
- * This adapter uses the OAuth token from Claude Code's credential store
- * (Keychain on macOS, credentials file elsewhere) to make direct API calls
- * to the Anthropic usage endpoint.
- */
-export const claudeAdapter = {
-    name: "Claude",
-    async fetchUsage() {
-        const accessToken = await getServiceAccessToken("claude");
-        if (!accessToken) {
+/** Fetch Claude usage data using a pre-resolved access token */
+async function fetchClaudeUsageWithToken(accessToken) {
+    try {
+        const [response, planType] = await Promise.all([
+            fetch(USAGE_API_URL, {
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    "anthropic-beta": ANTHROPIC_BETA_HEADER,
+                },
+            }),
+            fetchPlanType(accessToken),
+        ]);
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "");
             return {
                 ok: false,
-                error: new ApiError("No Claude credentials found. Run 'claude' to authenticate."),
-            };
-        }
-        try {
-            const [response, planType] = await Promise.all([
-                fetch(USAGE_API_URL, {
-                    headers: {
-                        Authorization: `Bearer ${accessToken}`,
-                        "anthropic-beta": ANTHROPIC_BETA_HEADER,
-                    },
-                }),
-                fetchPlanType(accessToken),
-            ]);
-            if (!response.ok) {
-                const errorText = await response.text().catch(() => "");
-                return {
-                    ok: false,
-                    error: new ApiError(`Claude API request failed: ${String(response.status)} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`, response.status),
-                };
-            }
-            const data = await response.json();
-            const parseResult = UsageResponseSchema.safeParse(coalesceClaudeUsageResponse(data) ?? data);
-            if (!parseResult.success) {
-                /* eslint-disable unicorn/no-null -- JSON.stringify requires null for no replacer */
-                console.error("Raw API response:", JSON.stringify(data, null, 2));
-                console.error("Validation errors:", JSON.stringify(z.treeifyError(parseResult.error), null, 2));
-                /* eslint-enable unicorn/no-null */
-                return {
-                    ok: false,
-                    error: new ApiError(`Invalid response format: ${parseResult.error.message}`, undefined, data),
-                };
-            }
-            const usageData = toServiceUsageData(parseResult.data);
-            return {
-                ok: true,
-                value: planType ? { ...usageData, planType } : usageData,
+                error: new ApiError(`Claude API request failed: ${String(response.status)} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`, response.status),
             };
         }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
+        const data = await response.json();
+        const parseResult = UsageResponseSchema.safeParse(coalesceClaudeUsageResponse(data) ?? data);
+        if (!parseResult.success) {
+            /* eslint-disable unicorn/no-null -- JSON.stringify requires null for no replacer */
+            console.error("Raw API response:", JSON.stringify(data, null, 2));
+            console.error("Validation errors:", JSON.stringify(z.treeifyError(parseResult.error), null, 2));
+            /* eslint-enable unicorn/no-null */
             return {
                 ok: false,
-                error: new ApiError(`Failed to fetch Claude usage: ${message}`),
+                error: new ApiError(`Invalid response format: ${parseResult.error.message}`, undefined, data),
             };
         }
-    },
+        const usageData = toServiceUsageData(parseResult.data);
+        return {
+            ok: true,
+            value: planType ? { ...usageData, planType } : usageData,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            error: new ApiError(`Failed to fetch Claude usage: ${message}`),
+        };
+    }
+}
+export const claudeUsageFetcher = {
+    name: "Claude",
+    fetchUsageWithToken: fetchClaudeUsageWithToken,
 };

package/dist/adapters/codex.d.ts

@@ -1,8 +1,2 @@
-import type { ServiceAdapter } from "../types/domain.js";
-/**
- * ChatGPT service adapter using direct API access.
- *
- * Uses the OAuth token from Codex CLI's credential store (~/.codex/auth.json)
- * to make direct API calls to ChatGPT's usage endpoint.
- */
-export declare const codexAdapter: ServiceAdapter;
+import type { ServiceUsageFetcher } from "../types/domain.js";
+export declare const codexUsageFetcher: ServiceUsageFetcher;

package/dist/adapters/codex.js

@@ -1,55 +1,43 @@
 import { ApiError } from "../types/domain.js";
-import { getServiceAccessToken } from "../services/get-service-access-token.js";
 import { CodexUsageResponse as CodexUsageResponseSchema } from "../types/codex.js";
 import { toServiceUsageData } from "./parse-codex-usage.js";
 const API_URL = "https://chatgpt.com/backend-api/wham/usage";
-/**
- * ChatGPT service adapter using direct API access.
- *
- * Uses the OAuth token from Codex CLI's credential store (~/.codex/auth.json)
- * to make direct API calls to ChatGPT's usage endpoint.
- */
-export const codexAdapter = {
-    name: "ChatGPT",
-    async fetchUsage() {
-        const accessToken = await getServiceAccessToken("codex");
-        if (!accessToken) {
+/** Fetch ChatGPT usage data using a pre-resolved access token */
+async function fetchCodexUsageWithToken(accessToken) {
+    try {
+        const response = await fetch(API_URL, {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "");
             return {
                 ok: false,
-                error: new ApiError("No Codex credentials found. Run 'codex' to authenticate."),
+                error: new ApiError(`ChatGPT API request failed: ${String(response.status)} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`, response.status),
             };
         }
-        try {
-            const response = await fetch(API_URL, {
-                headers: {
-                    Authorization: `Bearer ${accessToken}`,
-                },
-            });
-            if (!response.ok) {
-                const errorText = await response.text().catch(() => "");
-                return {
-                    ok: false,
-                    error: new ApiError(`ChatGPT API request failed: ${String(response.status)} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`, response.status),
-                };
-            }
-            const data = await response.json();
-            const parseResult = CodexUsageResponseSchema.safeParse(data);
-            if (!parseResult.success) {
-                return {
-                    ok: false,
-                    error: new ApiError(`Invalid response format: ${parseResult.error.message}`, undefined, data),
-                };
-            }
-            return {
-                ok: true,
-                value: toServiceUsageData(parseResult.data),
-            };
-        }
-        catch (error) {
+        const data = await response.json();
+        const parseResult = CodexUsageResponseSchema.safeParse(data);
+        if (!parseResult.success) {
             return {
                 ok: false,
-                error: new ApiError(`Failed to fetch ChatGPT usage: ${error instanceof Error ? error.message : String(error)}`),
+                error: new ApiError(`Invalid response format: ${parseResult.error.message}`, undefined, data),
             };
         }
-    },
+        return {
+            ok: true,
+            value: toServiceUsageData(parseResult.data),
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: new ApiError(`Failed to fetch ChatGPT usage: ${error instanceof Error ? error.message : String(error)}`),
+        };
+    }
+}
+export const codexUsageFetcher = {
+    name: "ChatGPT",
+    fetchUsageWithToken: fetchCodexUsageWithToken,
 };

package/dist/adapters/copilot.d.ts

@@ -1,7 +1,2 @@
-import type { ServiceAdapter } from "../types/domain.js";
-/**
- * GitHub Copilot service adapter using token-based API access.
- *
- * Credentials resolved via getServiceAccessToken (vault, local axauth, gh CLI).
- */
-export declare const copilotAdapter: ServiceAdapter;
+import type { ServiceUsageFetcher } from "../types/domain.js";
+export declare const copilotUsageFetcher: ServiceUsageFetcher;

package/dist/adapters/copilot.js

@@ -1,58 +1,47 @@
 import { ApiError } from "../types/domain.js";
 import { CopilotUsageResponse as CopilotUsageResponseSchema } from "../types/copilot.js";
 import { toServiceUsageData } from "./parse-copilot-usage.js";
-import { getServiceAccessToken } from "../services/get-service-access-token.js";
 // Internal/undocumented GitHub API used by VS Code, JetBrains, and other
 // first-party Copilot integrations. May change without notice.
 const API_URL = "https://api.github.com/copilot_internal/user";
-/**
- * GitHub Copilot service adapter using token-based API access.
- *
- * Credentials resolved via getServiceAccessToken (vault, local axauth, gh CLI).
- */
-export const copilotAdapter = {
-    name: "GitHub Copilot",
-    async fetchUsage() {
-        const accessToken = await getServiceAccessToken("copilot");
-        if (!accessToken) {
+/** Fetch GitHub Copilot usage data using a pre-resolved access token */
+async function fetchCopilotUsageWithToken(accessToken) {
+    try {
+        const response = await fetch(API_URL, {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                Accept: "application/json",
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "");
             return {
                 ok: false,
-                error: new ApiError("No GitHub Copilot credentials found. Run 'gh auth login' to authenticate."),
+                error: new ApiError(`GitHub Copilot API request failed: ${String(response.status)} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`, response.status),
             };
         }
-        try {
-            const response = await fetch(API_URL, {
-                headers: {
-                    Authorization: `Bearer ${accessToken}`,
-                    Accept: "application/json",
-                },
-            });
-            if (!response.ok) {
-                const errorText = await response.text().catch(() => "");
-                return {
-                    ok: false,
-                    error: new ApiError(`GitHub Copilot API request failed: ${String(response.status)} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`, response.status),
-                };
-            }
-            const data = await response.json();
-            const parseResult = CopilotUsageResponseSchema.safeParse(data);
-            if (!parseResult.success) {
-                return {
-                    ok: false,
-                    error: new ApiError(`Invalid response format: ${parseResult.error.message}`, undefined, data),
-                };
-            }
-            return {
-                ok: true,
-                value: toServiceUsageData(parseResult.data),
-            };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
+        const data = await response.json();
+        const parseResult = CopilotUsageResponseSchema.safeParse(data);
+        if (!parseResult.success) {
             return {
                 ok: false,
-                error: new ApiError(`Failed to fetch GitHub Copilot usage: ${message}`),
+                error: new ApiError(`Invalid response format: ${parseResult.error.message}`, undefined, data),
             };
         }
-    },
+        return {
+            ok: true,
+            value: toServiceUsageData(parseResult.data),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            error: new ApiError(`Failed to fetch GitHub Copilot usage: ${message}`),
+        };
+    }
+}
+export const copilotUsageFetcher = {
+    name: "GitHub Copilot",
+    fetchUsageWithToken: fetchCopilotUsageWithToken,
 };

package/dist/adapters/gemini.d.ts

@@ -1,8 +1,2 @@
-import type { ServiceAdapter } from "../types/domain.js";
-/**
- * Gemini service adapter using direct API access.
- *
- * Uses the OAuth token from Gemini CLI's credential store (~/.gemini/oauth_creds.json)
- * to make direct API calls to Google's quota endpoint.
- */
-export declare const geminiAdapter: ServiceAdapter;
+import type { ServiceUsageFetcher } from "../types/domain.js";
+export declare const geminiUsageFetcher: ServiceUsageFetcher;

package/dist/adapters/gemini.js

@@ -1,43 +1,31 @@
 import { ApiError } from "../types/domain.js";
 import { fetchGeminiQuota, fetchGeminiProject, } from "../services/gemini-api.js";
-import { getServiceAccessToken } from "../services/get-service-access-token.js";
 import { toServiceUsageData } from "./parse-gemini-usage.js";
-/**
- * Gemini service adapter using direct API access.
- *
- * Uses the OAuth token from Gemini CLI's credential store (~/.gemini/oauth_creds.json)
- * to make direct API calls to Google's quota endpoint.
- */
-export const geminiAdapter = {
-    name: "Gemini",
-    async fetchUsage() {
-        const accessToken = await getServiceAccessToken("gemini");
-        if (!accessToken) {
-            return {
-                ok: false,
-                error: new ApiError("No Gemini credentials found. Run 'gemini' to authenticate."),
-            };
-        }
-        try {
-            // Discover project ID for more accurate quotas (best effort)
-            const projectId = await fetchGeminiProject(accessToken);
-            // Fetch quota data
-            const quotaResult = await fetchGeminiQuota(accessToken, projectId);
-            if (!quotaResult.ok) {
-                return quotaResult;
-            }
-            return {
-                ok: true,
-                value: toServiceUsageData(quotaResult.value),
-            };
+/** Fetch Gemini usage data using a pre-resolved access token */
+async function fetchGeminiUsageWithToken(accessToken) {
+    try {
+        // Discover project ID for more accurate quotas (best effort)
+        const projectId = await fetchGeminiProject(accessToken);
+        // Fetch quota data
+        const quotaResult = await fetchGeminiQuota(accessToken, projectId);
+        if (!quotaResult.ok) {
+            return quotaResult;
         }
-        catch (error) {
-            return {
-                ok: false,
-                error: error instanceof ApiError
-                    ? error
-                    : new ApiError(`Failed to fetch Gemini usage: ${error instanceof Error ? error.message : String(error)}`),
-            };
-        }
-    },
+        return {
+            ok: true,
+            value: toServiceUsageData(quotaResult.value),
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof ApiError
+                ? error
+                : new ApiError(`Failed to fetch Gemini usage: ${error instanceof Error ? error.message : String(error)}`),
+        };
+    }
+}
+export const geminiUsageFetcher = {
+    name: "Gemini",
+    fetchUsageWithToken: fetchGeminiUsageWithToken,
 };

package/dist/adapters/parse-claude-usage.js

@@ -27,6 +27,7 @@ const parseResetTimestamp = (timestamp) => {
 export function toServiceUsageData(response) {
     return {
         service: "Claude",
+        serviceType: "claude",
         windows: [
             {
                 name: "5-Hour Usage",

package/dist/adapters/parse-codex-usage.js

@@ -15,6 +15,7 @@ export function toUsageWindow(name, window) {
 export function toServiceUsageData(response) {
     return {
         service: "ChatGPT",
+        serviceType: "codex",
         planType: response.plan_type,
         windows: [
             toUsageWindow("Primary Window (~5 hours)", response.rate_limit.primary_window),

package/dist/adapters/parse-copilot-usage.js

@@ -29,6 +29,7 @@ export function toServiceUsageData(response) {
     if (premium_interactions.unlimited) {
         return {
             service: "GitHub Copilot",
+            serviceType: "copilot",
             planType: response.copilot_plan,
             windows: [
                 {
@@ -48,6 +49,7 @@ export function toServiceUsageData(response) {
         : (used / premium_interactions.entitlement) * 100;
     return {
         service: "GitHub Copilot",
+        serviceType: "copilot",
         planType: response.copilot_plan,
         windows: [
             {

package/dist/adapters/parse-gemini-usage.js

@@ -145,6 +145,7 @@ export function toServiceUsageData(response, planType) {
     const windows = quotaPools.map((pool) => poolToUsageWindow(pool));
     return {
         service: "Gemini",
+        serviceType: "gemini",
         planType,
         windows,
     };

package/dist/cli.js

@@ -28,7 +28,7 @@ const program = new Command()
     .default("text"))
     .option("--auth-setup <service>", "set up authentication for a service (directs to appropriate CLI)")
     .option("--auth-status [service]", "check authentication status for services")
-    .addHelpText("after", () => `\nExamples:\n  # Fetch usage for all services\n  ${packageJson.name}\n\n  # JSON output for a single service\n  ${packageJson.name} --service claude --format json\n\n  # TSV output for piping to cut, awk, sort\n  ${packageJson.name} --format tsv | tail -n +2 | awk -F'\\t' '{print $1, $4"%"}'\n\n  # Filter Prometheus metrics with standard tools\n  ${packageJson.name} --format prometheus | grep axusage_utilization_percent\n\n  # Check authentication status for all services\n  ${packageJson.name} --auth-status\n\nSources config file: ${getCredentialSourcesPath()}\n(or set AXUSAGE_SOURCES to JSON to bypass file)\n\n${formatRequiresHelpText()}\nOverride CLI paths: AXUSAGE_CLAUDE_PATH, AXUSAGE_CODEX_PATH, AXUSAGE_GEMINI_PATH, AXUSAGE_GH_PATH\n`);
+    .addHelpText("after", () => `\nExamples:\n  # Fetch usage for all services\n  ${packageJson.name}\n\n  # JSON output for a single service\n  ${packageJson.name} --service claude --format json\n\n  # TSV output for piping to cut, awk, sort\n  ${packageJson.name} --format tsv | tail -n +2 | awk -F'\\t' '{print $1, $5"%"}'\n\n  # Filter Prometheus metrics with standard tools\n  ${packageJson.name} --format prometheus | grep axusage_utilization_percent\n\n  # Check authentication status for all services\n  ${packageJson.name} --auth-status\n\nSources config file: ${getCredentialSourcesPath()}\n(or set AXUSAGE_SOURCES to JSON to bypass file)\n\n${formatRequiresHelpText()}\nOverride CLI paths: AXUSAGE_CLAUDE_PATH, AXUSAGE_CODEX_PATH, AXUSAGE_GEMINI_PATH, AXUSAGE_GH_PATH\n`);
 program
     .command("serve")
     .description("Start HTTP server exposing Prometheus metrics at /metrics and usage JSON at /usage")

package/dist/commands/fetch-service-usage.d.ts

@@ -1,7 +1,13 @@
-import type { ApiError, Result, ServiceUsageData } from "../types/domain.js";
+import type { ServiceResult } from "../types/domain.js";
 export type UsageCommandOptions = {
     readonly service?: string;
     readonly format?: "text" | "tsv" | "json" | "prometheus";
 };
 export declare function selectServicesToQuery(service?: string): string[];
-export declare function fetchServiceUsage(serviceName: string): Promise<Result<ServiceUsageData, ApiError>>;
+/**
+ * Fetch usage for all instances of a service type.
+ *
+ * Resolves tokens and fetches usage for each configured instance in parallel.
+ * Produces N results with resolved display names and stable instance IDs.
+ */
+export declare function fetchServiceInstanceUsage(serviceType: string): Promise<ServiceResult[]>;

package/dist/commands/fetch-service-usage.js

@@ -1,20 +1,87 @@
 import { ApiError as ApiErrorClass } from "../types/domain.js";
-import { getAvailableServices, getServiceAdapter, } from "../services/service-adapter-registry.js";
+import { getAvailableServices, getServiceUsageFetcher, } from "../services/service-adapter-registry.js";
+import { getServiceInstanceConfigs } from "../config/credential-sources.js";
+import { getInstanceAccessToken } from "../services/get-instance-access-token.js";
+import { resolveInstanceDisplayName } from "../services/resolve-service-instances.js";
 export function selectServicesToQuery(service) {
     const normalized = service?.toLowerCase();
     if (!service || normalized === "all")
         return getAvailableServices();
     return [service];
 }
-export async function fetchServiceUsage(serviceName) {
-    const adapter = getServiceAdapter(serviceName);
-    if (!adapter) {
+/**
+ * Derive a stable instance identifier for metrics labeling.
+ * Uses credential name when available, otherwise falls back to service type.
+ */
+function deriveInstanceId(serviceType, credentialName, index, total) {
+    if (credentialName)
+        return credentialName;
+    if (total === 1)
+        return serviceType;
+    return `${serviceType}-${String(index + 1)}`;
+}
+/**
+ * Fetch usage for all instances of a service type.
+ *
+ * Resolves tokens and fetches usage for each configured instance in parallel.
+ * Produces N results with resolved display names and stable instance IDs.
+ */
+export async function fetchServiceInstanceUsage(serviceType) {
+    const normalized = serviceType.toLowerCase();
+    const fetcher = getServiceUsageFetcher(normalized);
+    if (!fetcher) {
         const available = getAvailableServices().join(", ");
+        return [
+            {
+                service: serviceType,
+                result: {
+                    ok: false,
+                    error: new ApiErrorClass(`Unknown service "${serviceType}". Supported services: ${available}. ` +
+                        "Run 'axusage --help' for usage."),
+                },
+            },
+        ];
+    }
+    const instanceConfigs = getServiceInstanceConfigs(normalized);
+    const results = await Promise.all(instanceConfigs.map(async (config, index) => {
+        const tokenResult = await getInstanceAccessToken(normalized, config);
+        if (!tokenResult.token) {
+            const label = config.name ?? normalized;
+            const isVaultPath = config.source === "vault" ||
+                (config.source === "auto" && config.name !== undefined);
+            return {
+                service: normalized,
+                result: {
+                    ok: false,
+                    error: new ApiErrorClass(`No credentials found for ${label}. ` +
+                        (isVaultPath
+                            ? config.name
+                                ? `Check that vault is configured and credential "${config.name}" exists.`
+                                : `Check that vault is configured. Set a credential name in config.`
+                            : `Run the agent CLI to authenticate.`)),
+                },
+            };
+        }
+        const usageResult = await fetcher.fetchUsageWithToken(tokenResult.token);
+        if (usageResult.ok) {
+            const displayName = resolveInstanceDisplayName(config.displayName, tokenResult.vaultDisplayName, fetcher.name, index, instanceConfigs.length);
+            const instanceId = deriveInstanceId(normalized, config.name, index, instanceConfigs.length);
+            return {
+                service: normalized,
+                result: {
+                    ok: true,
+                    value: {
+                        ...usageResult.value,
+                        service: displayName,
+                        instanceId,
+                    },
+                },
+            };
+        }
         return {
-            ok: false,
-            error: new ApiErrorClass(`Unknown service "${serviceName}". Supported services: ${available}. ` +
-                "Run 'axusage --help' for usage."),
+            service: normalized,
+            result: usageResult,
         };
-    }
-    return await adapter.fetchUsage();
+    }));
+    return results;
 }

package/dist/commands/serve-command.js

@@ -97,12 +97,15 @@ export async function serveCommand(options) {
             process.exit(1);
         }, 5000);
         forceExit.unref();
-        server.stop().then(() => {
+        server
+            .stop()
+            .finally(() => {
             clearTimeout(forceExit);
+        })
+            .then(() => {
             // eslint-disable-next-line unicorn/no-process-exit -- CLI graceful shutdown
             process.exit(0);
         }, (error) => {
-            clearTimeout(forceExit);
             console.error("Error during shutdown:", error);
             // eslint-disable-next-line unicorn/no-process-exit -- CLI graceful shutdown
             process.exit(1);