@juspay/neurolink 10.1.2 → 10.2.0

package/dist/cli/commands/proxy.js

@@ -41,6 +41,8 @@ const _require = createRequire(import.meta.url);
 const PROXY_VERSION = packageJson.version;
 const PROXY_TELEMETRY_SCRIPT_PATH = fileURLToPath(new URL("../../../scripts/observability/manage-local-openobserve.sh", import.meta.url));
 const PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS = 5_000;
+const LEGACY_STATUS_ACCOUNT_CACHE_TTL_MS = 5_000;
+let legacyStatusAccountCache;
 // Allowed drift between a pid's OS-reported start time and the persisted
 // ProxySupervisorState.startTime before processLooksLikeProxySupervisor
 // treats it as a confident mismatch (recycled pid). Generous on purpose:
@@ -323,6 +325,34 @@ async function resolveStatusPrimaryAccount(proxyConfig) {
         source: "fallback",
     };
 }
+async function resolveLegacyStatusAccountLabel(storedAnthropicAccountCount) {
+    if (storedAnthropicAccountCount !== 0) {
+        return null;
+    }
+    const credentialsPath = join(homedir(), ".neurolink", "anthropic-credentials.json");
+    const now = Date.now();
+    if (legacyStatusAccountCache?.credentialsPath === credentialsPath &&
+        legacyStatusAccountCache.expiresAt > now) {
+        return legacyStatusAccountCache.label;
+    }
+    let label = null;
+    try {
+        const { readFile } = await import("node:fs/promises");
+        const parsed = JSON.parse(await readFile(credentialsPath, "utf8"));
+        if (parsed.oauth?.accessToken) {
+            label = parsed.email?.trim() || "legacy-default";
+        }
+    }
+    catch {
+        label = null;
+    }
+    legacyStatusAccountCache = {
+        credentialsPath,
+        expiresAt: now + LEGACY_STATUS_ACCOUNT_CACHE_TTL_MS,
+        label,
+    };
+    return label;
+}
 /**
  * Check if the launchd service is loaded and actively managing the proxy.
  * Returns true if launchctl reports the service as running.
@@ -1492,23 +1522,32 @@ export async function createProxyStartApp(params) {
         const activeAccountAllowlist = runtimeConfig
             ? runtimeConfig.accountAllowlist
             : params.accountAllowlist;
-        const { getStats } = await import("../../lib/proxy/usageStats.js");
+        const { getReconciledStats, getUsageStatsPersistenceStatus } = await import("../../lib/proxy/usageStats.js");
         const { loadAccountCooldowns } = await import("../../lib/proxy/accountCooldown.js");
-        const stats = getStats();
+        const stats = await getReconciledStats();
         const runtimeState = loadProxyState();
         const supervisorState = loadProxySupervisorState();
         const updateState = loadUpdateState();
         const cooldowns = await loadAccountCooldowns();
         const storedAccountKeys = new Set();
+        const disabledAccountKeys = new Set();
+        let accountInventoryLoaded = false;
         try {
             const { tokenStore } = await import("../../lib/auth/tokenStore.js");
             for (const key of await tokenStore.listByPrefix("anthropic:")) {
                 storedAccountKeys.add(normalizeAnthropicAccountKey(key));
             }
+            for (const key of await tokenStore.listDisabled()) {
+                disabledAccountKeys.add(normalizeAnthropicAccountKey(key));
+            }
+            accountInventoryLoaded = true;
         }
         catch (err) {
             logger.debug(`[proxy] /status: failed to resolve account cooldown labels: ${err instanceof Error ? err.message : String(err)}`);
         }
+        const legacyAccountLabel = accountInventoryLoaded
+            ? await resolveLegacyStatusAccountLabel(storedAccountKeys.size)
+            : null;
         const now = Date.now();
         const health = buildProxyHealthResponse(readiness, {
             strategy: activeStrategy,
@@ -1530,6 +1569,7 @@ export async function createProxyStartApp(params) {
             version: PROXY_VERSION,
             health,
             stats: {
+                startedAt: stats.startedAt,
                 totalAttempts: stats.totalAttempts,
                 totalAttemptErrors: stats.totalAttemptErrors,
                 totalRequests: stats.totalRequests,
@@ -1540,13 +1580,25 @@ export async function createProxyStartApp(params) {
                 totalQuotaRateLimits: stats.totalQuotaRateLimits,
                 accounts: Object.values(stats.accounts).map((account) => {
                     const normalizedKey = normalizeAnthropicAccountKey(account.label);
+                    const isLegacyAccount = account.type === "oauth" && account.label === legacyAccountLabel;
                     const accountKey = storedAccountKeys.has(normalizedKey)
                         ? normalizedKey
-                        : account.label === "env"
-                            ? ENV_ANTHROPIC_ACCOUNT_KEY
-                            : account.type === "oauth"
-                                ? LEGACY_ANTHROPIC_ACCOUNT_KEY
+                        : isLegacyAccount
+                            ? LEGACY_ANTHROPIC_ACCOUNT_KEY
+                            : account.label === "env"
+                                ? ENV_ANTHROPIC_ACCOUNT_KEY
                                 : normalizedKey;
+                    const isStored = storedAccountKeys.has(accountKey) || isLegacyAccount;
+                    const cooling = (cooldowns[accountKey]?.coolingUntil ?? 0) > now;
+                    const accountStatus = disabledAccountKeys.has(accountKey)
+                        ? "disabled"
+                        : !isAccountAllowed(accountKey, activeAccountAllowlist)
+                            ? "excluded"
+                            : accountInventoryLoaded && account.type === "oauth" && !isStored
+                                ? "removed"
+                                : cooling
+                                    ? "cooling"
+                                    : "active";
                     return {
                         label: account.label,
                         type: account.type,
@@ -1558,10 +1610,12 @@ export async function createProxyStartApp(params) {
                         rateLimits: account.rateLimitCount,
                         transientRateLimits: account.transientRateLimitCount,
                         quotaRateLimits: account.quotaRateLimitCount,
-                        cooling: (cooldowns[accountKey]?.coolingUntil ?? 0) > now,
+                        cooling,
+                        status: accountStatus,
                     };
                 }),
                 primaryAccount,
+                persistence: getUsageStatsPersistenceStatus(),
             },
             activity: (() => {
                 const activity = getProxyActivitySnapshot();
@@ -1875,10 +1929,17 @@ function registerProxyShutdownHandlers(params) {
                 logger.error(`[proxy] failed to drain server during shutdown: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        try {
-            await withTimeout(flushProxyLifecycleEvents(), PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy lifecycle metadata during shutdown");
+        const usageStatsFlush = import("../../lib/proxy/usageStats.js").then(({ flushUsageStats }) => flushUsageStats());
+        const [usageStatsFlushResult, lifecycleFlushResult] = await Promise.allSettled([
+            withTimeout(usageStatsFlush, PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy usage statistics during shutdown"),
+            withTimeout(flushProxyLifecycleEvents(), PROXY_LIFECYCLE_SHUTDOWN_TIMEOUT_MS, "Timed out flushing proxy lifecycle metadata during shutdown"),
+        ]);
+        if (usageStatsFlushResult.status === "rejected") {
+            const error = usageStatsFlushResult.reason;
+            logger.warn(`[proxy] usage statistics flush failed during shutdown: ${error instanceof Error ? error.message : String(error)}`);
         }
-        catch (error) {
+        if (lifecycleFlushResult.status === "rejected") {
+            const error = lifecycleFlushResult.reason;
             logger.debug(`[proxy] lifecycle metadata flush failed during shutdown: ${error instanceof Error ? error.message : String(error)}`);
         }
         try {
@@ -2284,9 +2345,10 @@ async function startProxyCommandHandler(argv) {
         }
         // In dev mode: redirect writable state to .neurolink-dev/ and skip singleton check
         let devPaths;
+        const { resolveProxyPaths, resolveProxyUsageStatsPath } = await import("../../lib/proxy/proxyPaths.js");
+        const proxyPaths = resolveProxyPaths(isDev);
         if (isDev) {
-            const { resolveProxyPaths } = await import("../../lib/proxy/proxyPaths.js");
-            devPaths = resolveProxyPaths(true);
+            devPaths = proxyPaths;
             setProxyStateDir(devPaths.stateDir);
             const { initAccountQuota } = await import("../../lib/proxy/accountQuota.js");
             initAccountQuota(devPaths.quotaFile);
@@ -2301,6 +2363,15 @@ async function startProxyCommandHandler(argv) {
         if (!isDev && !socketWorker) {
             await ensureProxyStartAllowed(spinner);
         }
+        const { initUsageStats, getUsageStatsPersistenceStatus } = await import("../../lib/proxy/usageStats.js");
+        await initUsageStats(resolveProxyUsageStatsPath(proxyPaths));
+        const usageStatsPersistence = getUsageStatsPersistenceStatus();
+        if (usageStatsPersistence.lastError) {
+            logger.warn(`[proxy] usage statistics persistence unavailable: ${usageStatsPersistence.lastError}`);
+        }
+        else if (usageStatsPersistence.lastRecoveryAt) {
+            logger.warn(`[proxy] recovered corrupt usage statistics state at ${new Date(usageStatsPersistence.lastRecoveryAt).toISOString()}`);
+        }
         const baseEnv = { ...process.env };
         const envResolution = resolveProxyEnvFile({
             explicitEnvFile: argv.envFile,
@@ -2485,7 +2556,7 @@ function printStatusStats(stats) {
             String(account.success ?? 0),
             String(account.errors ?? 0),
             String(account.rateLimits ?? 0),
-            account.cooling ? "cooling" : "active",
+            account.status ?? (account.cooling ? "cooling" : "active"),
         ]);
         const widths = headers.map((header, index) => Math.max(header.length, ...rows.map((row) => row[index].length)));
         const numericColumns = new Set([2, 3, 4, 5]);
@@ -2503,7 +2574,7 @@ function printStatusStats(stats) {
             const statusStart = formatted.length - widths[6];
             const prefix = formatted.slice(0, statusStart);
             const paddedStatus = formatted.slice(statusStart);
-            console.info(`    ${chalk.cyan(prefix.slice(0, widths[0]))}${prefix.slice(widths[0])}${status === "cooling" ? chalk.red(paddedStatus) : chalk.green(paddedStatus)}`);
+            console.info(`    ${chalk.cyan(prefix.slice(0, widths[0]))}${prefix.slice(widths[0])}${status === "active" ? chalk.green(paddedStatus) : status === "cooling" ? chalk.red(paddedStatus) : chalk.yellow(paddedStatus)}`);
         }
     }
 }

package/dist/lib/proxy/proxyPaths.d.ts

@@ -14,3 +14,4 @@
  */
 import type { ProxyPaths } from "../types/index.js";
 export declare function resolveProxyPaths(dev: boolean): ProxyPaths;
+export declare function resolveProxyUsageStatsPath(paths: ProxyPaths): string;

package/dist/lib/proxy/proxyPaths.js

@@ -22,6 +22,7 @@ export function resolveProxyPaths(dev) {
             logsDir: join(base, "logs"),
             quotaFile: join(base, "account-quotas.json"),
             cooldownFile: join(base, "account-cooldowns.json"),
+            statsFile: join(base, "proxy-usage-stats.json"),
             isDev: true,
         };
     }
@@ -31,7 +32,11 @@ export function resolveProxyPaths(dev) {
         logsDir: join(base, "logs"),
         quotaFile: join(base, "account-quotas.json"),
         cooldownFile: join(base, "account-cooldowns.json"),
+        statsFile: join(base, "proxy-usage-stats.json"),
         isDev: false,
     };
 }
+export function resolveProxyUsageStatsPath(paths) {
+    return paths.statsFile ?? join(paths.stateDir, "proxy-usage-stats.json");
+}
 //# sourceMappingURL=proxyPaths.js.map

package/dist/lib/proxy/usageStats.d.ts

@@ -1,13 +1,67 @@
 /**
- * Proxy Usage Statistics
- * Tracks per-account request counts, token usage, and error rates.
- * In-memory only — resets on proxy restart.
+ * Proxy usage statistics with restart- and handoff-safe persistence.
+ *
+ * Request handlers update memory synchronously. Small deltas are merged into a
+ * shared snapshot asynchronously, under a cross-process lock, so overlapping
+ * rolling workers cannot overwrite each other's counters.
  */
-import type { AccountStats, ProxyStats } from "../types/index.js";
+import type { AccountStats, ProxyStats, ProxyStatsPersistenceStatus, ProxyUsageStatsStoreOptions } from "../types/index.js";
+export declare class ProxyUsageStatsStore {
+    private readonly now;
+    private readonly flushIntervalMs;
+    private readonly lockTimeoutMs;
+    private readonly staleLockMs;
+    private filePath?;
+    private stats;
+    private pending;
+    private pendingMutations;
+    private inFlightMutations;
+    private revision;
+    private flushTimer;
+    private readonly flushMutex;
+    private lastFlushedAt?;
+    private lastReconciledAt?;
+    private lastRecoveryAt?;
+    private lastError?;
+    constructor(options?: ProxyUsageStatsStoreOptions);
+    initialize(filePath?: string): Promise<void>;
+    recordAttempt(accountLabel: string, accountType: string): void;
+    recordFinalSuccess(accountLabel?: string, accountType?: string): void;
+    recordAttemptError(accountLabel: string, accountType: string, status: number, rateLimitKind?: "transient" | "quota"): void;
+    recordFinalError(_status: number, accountLabel?: string, accountType?: string): void;
+    getStats(): ProxyStats;
+    getAccountStats(label: string): AccountStats | undefined;
+    getPersistenceStatus(): ProxyStatsPersistenceStatus;
+    flush(): Promise<void>;
+    reconcile(): Promise<ProxyStats>;
+    resetMemory(): void;
+    resetForTests(): Promise<void>;
+    private markMutation;
+    private applyAttempt;
+    private applyFinalSuccess;
+    private applyAttemptError;
+    private applyFinalError;
+    private ensureAccount;
+    private scheduleFlush;
+    private cancelFlushTimer;
+    private readSnapshot;
+    private applySnapshot;
+    private recoverCorruptSnapshot;
+    private quarantineCorruptSnapshot;
+    private pruneCorruptSnapshots;
+    private describeError;
+}
+export declare function initUsageStats(filePath: string): Promise<void>;
 export declare function recordAttempt(accountLabel: string, accountType: string): void;
 export declare function recordFinalSuccess(accountLabel?: string, accountType?: string): void;
 export declare function recordAttemptError(accountLabel: string, accountType: string, status: number, rateLimitKind?: "transient" | "quota"): void;
 export declare function recordFinalError(_status: number, accountLabel?: string, accountType?: string): void;
 export declare function getStats(): ProxyStats;
+export declare function getReconciledStats(): Promise<ProxyStats>;
 export declare function getAccountStats(label: string): AccountStats | undefined;
+export declare function getUsageStatsPersistenceStatus(): ProxyStatsPersistenceStatus;
+export declare function flushUsageStats(): Promise<void>;
+/** Reset process-local counters while intentionally preserving durable state. */
 export declare function resetStats(): void;
+/** Disconnect persistence and clear singleton state between isolated tests. */
+export declare function resetUsageStatsForTests(): Promise<void>;