@juspay/neurolink 9.50.1 → 9.51.0

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

@@ -16,6 +16,12 @@ import type { AccountQuota } from "../types/index.js";
  * Pure computation — no I/O, no blocking.
  */
 export declare function parseQuotaHeaders(headers: Headers | Record<string, string>): AccountQuota | null;
+/**
+ * Initialise the quota module with a custom file path.
+ * When set, all reads/writes go to this path instead of the default
+ * ~/.neurolink/account-quotas.json. Call before the first load/save.
+ */
+export declare function initAccountQuota(quotaFilePath: string): void;
 /**
  * Load all persisted account quotas.
  * First call reads from disk; subsequent calls return the in-memory cache.

package/dist/lib/proxy/accountQuota.js

@@ -9,7 +9,7 @@
  * updates an in-memory cache and debounces disk writes so the request/response
  * path is never blocked by file I/O.
  */
-import { join } from "path";
+import { dirname, join } from "path";
 import { homedir } from "os";
 import { promises as fs } from "fs";
 // ---------------------------------------------------------------------------
@@ -73,11 +73,32 @@ let memoryCache = {};
 let cacheLoaded = false;
 let dirty = false;
 let flushTimer = null;
+/** Custom quota file path set via initAccountQuota(). */
+let customQuotaFilePath = null;
+/**
+ * Initialise the quota module with a custom file path.
+ * When set, all reads/writes go to this path instead of the default
+ * ~/.neurolink/account-quotas.json. Call before the first load/save.
+ */
+export function initAccountQuota(quotaFilePath) {
+    customQuotaFilePath = quotaFilePath;
+    // Cancel any pending flush from a previous configuration so it does not
+    // write stale data to the new path.
+    if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+    }
+    // Reset cache so the new path is picked up on next load
+    memoryCache = {};
+    cacheLoaded = false;
+    dirty = false;
+}
 function getQuotaFilePath() {
-    return join(homedir(), ".neurolink", QUOTA_FILE);
+    return customQuotaFilePath ?? join(homedir(), ".neurolink", QUOTA_FILE);
 }
 async function ensureDir() {
-    const dir = join(homedir(), ".neurolink");
+    const filePath = getQuotaFilePath();
+    const dir = dirname(filePath);
     await fs.mkdir(dir, { recursive: true, mode: 0o700 }).catch(() => {
         // Non-fatal: directory may already exist
     });

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

@@ -0,0 +1,25 @@
+/**
+ * Proxy file path resolver.
+ *
+ * In normal mode, all paths resolve under ~/.neurolink/.
+ * In dev mode (--dev), writable paths resolve under <cwd>/.neurolink-dev/
+ * so a local dev proxy never touches the global proxy's state.
+ *
+ * Read-only paths (like .env) always point to the global location
+ * since credentials must be shared.
+ *
+ * NOTE: Claude Code header snapshots (~/.neurolink/header-snapshots/) are
+ * not redirected in dev mode. They are only written when a real Claude Code
+ * client connects, which typically does not happen during dev testing.
+ */
+export type ProxyPaths = {
+    /** Base directory for proxy state files */
+    stateDir: string;
+    /** logs/ — request/response logs */
+    logsDir: string;
+    /** account-quotas.json — per-account rate limit state */
+    quotaFile: string;
+    /** Whether this is a dev-mode isolated instance */
+    isDev: boolean;
+};
+export declare function resolveProxyPaths(dev: boolean): ProxyPaths;

package/dist/lib/proxy/proxyPaths.js

@@ -0,0 +1,35 @@
+/**
+ * Proxy file path resolver.
+ *
+ * In normal mode, all paths resolve under ~/.neurolink/.
+ * In dev mode (--dev), writable paths resolve under <cwd>/.neurolink-dev/
+ * so a local dev proxy never touches the global proxy's state.
+ *
+ * Read-only paths (like .env) always point to the global location
+ * since credentials must be shared.
+ *
+ * NOTE: Claude Code header snapshots (~/.neurolink/header-snapshots/) are
+ * not redirected in dev mode. They are only written when a real Claude Code
+ * client connects, which typically does not happen during dev testing.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function resolveProxyPaths(dev) {
+    if (dev) {
+        const base = join(process.cwd(), ".neurolink-dev");
+        return {
+            stateDir: base,
+            logsDir: join(base, "logs"),
+            quotaFile: join(base, "account-quotas.json"),
+            isDev: true,
+        };
+    }
+    const base = join(homedir(), ".neurolink");
+    return {
+        stateDir: base,
+        logsDir: join(base, "logs"),
+        quotaFile: join(base, "account-quotas.json"),
+        isDev: false,
+    };
+}
+//# sourceMappingURL=proxyPaths.js.map

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

@@ -6,7 +6,7 @@
  * Useful for debugging and auditing proxy traffic.
  */
 import type { RequestAttemptLogEntry, RequestLogEntry } from "../types/index.js";
-export declare function initRequestLogger(enabled?: boolean): void;
+export declare function initRequestLogger(enabled?: boolean, customLogsDir?: string): void;
 export declare function logRequest(entry: RequestLogEntry): Promise<void>;
 /**
  * Log an upstream attempt separately from the final request outcome.

package/dist/lib/proxy/requestLogger.js

@@ -44,13 +44,13 @@ const SENSITIVE_HEADER_NAMES = new Set([
 const SENSITIVE_HEADER_PATTERN = /token|secret|key|password|credential/i;
 /** JSON keys whose values should be redacted in request/response bodies. */
 const SENSITIVE_BODY_KEYS = /("(?:password|access_token|refresh_token|api_key|apiKey|secret|authorization|token|credential|x-api-key)"\s*:\s*)"(?:[^"\\]|\\.)*"/gi;
-export function initRequestLogger(enabled = true) {
+export function initRequestLogger(enabled = true, customLogsDir) {
     logEnabled = enabled;
     if (!enabled) {
         return;
     }
     try {
-        logDir = join(homedir(), ".neurolink", "logs");
+        logDir = customLogsDir ?? join(homedir(), ".neurolink", "logs");
         if (!existsSync(logDir)) {
             mkdirSync(logDir, { recursive: true, mode: 0o700 });
         }

package/dist/lib/services/server/ai/observability/instrumentation.js

@@ -445,7 +445,45 @@ function initializeExternalOpenTelemetryMode(config, resource, otlpEndpoint, ser
             const provider = globalProvider;
             if (globalProvider && typeof provider.addSpanProcessor === "function") {
                 provider.addSpanProcessor(new ContextEnricher());
-                const skipLangfuse = config.skipLangfuseSpanProcessor === true || !langfuseProcessor;
+                // Auto-detect: skip if consumer already registered a LangfuseSpanProcessor.
+                //
+                // Detection strategy (ordered by robustness):
+                // 1. `instanceof LangfuseSpanProcessor` — reliable when both sides use
+                //    the same @langfuse/otel package instance (same module identity).
+                // 2. Duck-type check for Langfuse-specific public member
+                //    (`langfuseClient` property) — survives minification.
+                // 3. `constructor.name === "LangfuseSpanProcessor"` — last resort,
+                //    brittle under minification or bundler renaming.
+                //
+                // NOTE: `_registeredSpanProcessors` is an internal OpenTelemetry field.
+                // If the OTel SDK removes or renames it, the array defaults to [] and
+                // `hasExistingLangfuse` is false — NeuroLink registers its own processor
+                // (same behavior as before this check). Consumers can always force skip
+                // via `skipLangfuseSpanProcessor: true`.
+                const existingProcessors = provider
+                    ._registeredSpanProcessors ?? [];
+                const hasExistingLangfuse = existingProcessors.some((p) => {
+                    if (p === null || p === undefined || typeof p !== "object") {
+                        return false;
+                    }
+                    // Prefer instanceof — works when same @langfuse/otel package is shared
+                    if (p instanceof LangfuseSpanProcessor) {
+                        return true;
+                    }
+                    // Duck-type: Langfuse processor exposes a langfuseClient property
+                    if ("langfuseClient" in p) {
+                        return true;
+                    }
+                    // Fallback: constructor name (brittle under minification)
+                    return (p.constructor?.name ===
+                        "LangfuseSpanProcessor");
+                });
+                const skipLangfuse = config.skipLangfuseSpanProcessor === true ||
+                    !langfuseProcessor ||
+                    hasExistingLangfuse;
+                if (hasExistingLangfuse && !config.skipLangfuseSpanProcessor) {
+                    logger.info(`${LOG_PREFIX} Auto-detected existing LangfuseSpanProcessor — skipping SDK registration to avoid duplicates`);
+                }
                 if (!skipLangfuse && langfuseProcessor) {
                     provider.addSpanProcessor(langfuseProcessor);
                 }

package/dist/lib/types/cli.d.ts

@@ -765,6 +765,7 @@ export type ProxyStartArgs = {
     config?: string;
     envFile?: string;
     passthrough?: boolean;
+    dev?: boolean;
 };
 /** Arguments accepted by `neurolink proxy status` */
 export type ProxyStatusArgs = {

package/dist/lib/types/externalMcp.d.ts

@@ -228,6 +228,7 @@ export type ExternalMCPServerEvents = {
     /** Server status changed */
     statusChanged: {
         serverId: string;
+        serverName: string;
         oldStatus: ExternalMCPServerStatus;
         newStatus: ExternalMCPServerStatus;
         timestamp: Date;
@@ -235,24 +236,28 @@ export type ExternalMCPServerEvents = {
     /** Server connected successfully */
     connected: {
         serverId: string;
+        serverName: string;
         toolCount: number;
         timestamp: Date;
     };
     /** Server disconnected */
     disconnected: {
         serverId: string;
+        serverName: string;
         reason?: string;
         timestamp: Date;
     };
     /** Server failed */
     failed: {
         serverId: string;
+        serverName: string;
         error: string;
         timestamp: Date;
     };
     /** Tool discovered */
     toolDiscovered: {
         serverId: string;
+        serverName: string;
         toolName: string;
         toolInfo: ExternalMCPToolInfo;
         timestamp: Date;
@@ -260,12 +265,14 @@ export type ExternalMCPServerEvents = {
     /** Tool removed */
     toolRemoved: {
         serverId: string;
+        serverName: string;
         toolName: string;
         timestamp: Date;
     };
     /** Health check completed */
     healthCheck: {
         serverId: string;
+        serverName: string;
         health: ExternalMCPServerHealth;
         timestamp: Date;
     };

package/dist/mcp/externalServerManager.d.ts

@@ -36,6 +36,11 @@ export declare class ExternalServerManager extends EventEmitter {
      * Get current HITL manager
      */
     getHITLManager(): HITLManager | undefined;
+    /**
+     * Resolve the human-readable server name for an event payload.
+     * Falls back to serverId if the instance or config.name isn't available.
+     */
+    getServerName(serverId: string): string;
     /**
      * Load MCP server configurations from .mcp-config.json file with parallel loading support
      * Automatically registers servers found in the configuration

package/dist/mcp/externalServerManager.js

@@ -194,10 +194,16 @@ export class ExternalServerManager extends EventEmitter {
         this.toolDiscovery = new ToolDiscoveryService();
         // Forward tool discovery events
         this.toolDiscovery.on("toolRegistered", (event) => {
-            this.emit("toolDiscovered", event);
+            this.emit("toolDiscovered", {
+                ...event,
+                serverName: this.getServerName(event.serverId),
+            });
         });
         this.toolDiscovery.on("toolUnregistered", (event) => {
-            this.emit("toolRemoved", event);
+            this.emit("toolRemoved", {
+                ...event,
+                serverName: this.getServerName(event.serverId),
+            });
         });
         // Handle process cleanup
         process.on("SIGINT", () => this.shutdown());
@@ -223,6 +229,14 @@ export class ExternalServerManager extends EventEmitter {
     getHITLManager() {
         return this.hitlManager;
     }
+    /**
+     * Resolve the human-readable server name for an event payload.
+     * Falls back to serverId if the instance or config.name isn't available.
+     */
+    getServerName(serverId) {
+        const instance = this.servers.get(serverId);
+        return instance?.config?.name || serverId;
+    }
     /**
      * Load MCP server configurations from .mcp-config.json file with parallel loading support
      * Automatically registers servers found in the configuration
@@ -712,6 +726,8 @@ export class ExternalServerManager extends EventEmitter {
                 };
             }
             mcpLogger.info(`[ExternalServerManager] Removing server: ${serverId}`);
+            // Capture name before deletion removes the instance
+            const serverName = this.getServerName(serverId);
             // Stop the server
             await this.stopServer(serverId);
             // Remove from registry
@@ -719,6 +735,7 @@ export class ExternalServerManager extends EventEmitter {
             // Emit event
             this.emit("disconnected", {
                 serverId,
+                serverName,
                 reason: "Manually removed",
                 timestamp: new Date(),
             });
@@ -816,6 +833,7 @@ export class ExternalServerManager extends EventEmitter {
             // Emit connected event
             this.emit("connected", {
                 serverId,
+                serverName: this.getServerName(serverId),
                 toolCount: instance.toolsMap.size,
                 timestamp: new Date(),
             });
@@ -921,6 +939,7 @@ export class ExternalServerManager extends EventEmitter {
         // Emit status change event
         this.emit("statusChanged", {
             serverId,
+            serverName: this.getServerName(serverId),
             oldStatus,
             newStatus,
             timestamp: new Date(),
@@ -941,6 +960,7 @@ export class ExternalServerManager extends EventEmitter {
         // Emit failed event
         this.emit("failed", {
             serverId,
+            serverName: this.getServerName(serverId),
             error: error.message,
             timestamp: new Date(),
         });
@@ -965,6 +985,7 @@ export class ExternalServerManager extends EventEmitter {
         // Emit disconnected event
         this.emit("disconnected", {
             serverId,
+            serverName: this.getServerName(serverId),
             reason,
             timestamp: new Date(),
         });
@@ -1078,6 +1099,7 @@ export class ExternalServerManager extends EventEmitter {
             // Emit health check event
             this.emit("healthCheck", {
                 serverId,
+                serverName: this.getServerName(serverId),
                 health,
                 timestamp: new Date(),
             });

package/dist/neurolink.js

@@ -50,7 +50,7 @@ import { createMemoryRetrievalTools } from "./memory/memoryRetrievalTools.js";
 import { getMetricsAggregator, MetricsAggregator, } from "./observability/metricsAggregator.js";
 import { SpanStatus, SpanType } from "./observability/types/spanTypes.js";
 import { SpanSerializer } from "./observability/utils/spanSerializer.js";
-import { flushOpenTelemetry, getLangfuseHealthStatus, initializeOpenTelemetry, isOpenTelemetryInitialized, setLangfuseContext, shutdownOpenTelemetry, } from "./services/server/ai/observability/instrumentation.js";
+import { flushOpenTelemetry, getLangfuseHealthStatus, initializeOpenTelemetry, isOpenTelemetryInitialized, runWithCurrentLangfuseContext, setLangfuseContext, shutdownOpenTelemetry, } from "./services/server/ai/observability/instrumentation.js";
 import { TaskManager } from "./tasks/taskManager.js";
 import { createTaskTools } from "./tasks/tools/taskTools.js";
 import { ATTR } from "./telemetry/attributes.js";
@@ -1129,7 +1129,10 @@ Current user's request: ${currentInput}`;
      * Supports additional users with per-user prompt and maxWords overrides.
      */
     storeMemoryInBackground(originalPrompt, responseContent, userId, additionalUsers) {
-        setImmediate(async () => {
+        // Preserve AsyncLocalStorage context across setImmediate boundary so that
+        // memory writes appear under the originating Langfuse trace instead of
+        // becoming orphan spans.
+        const wrappedMemoryWrite = runWithCurrentLangfuseContext(async () => {
             try {
                 const client = this.ensureMemoryReady();
                 if (!client) {
@@ -1145,12 +1148,18 @@ Current user's request: ${currentInput}`;
                         : undefined;
                     writeOps.push(client.add(user.userId, content, addOptions));
                 }
-                await Promise.all(writeOps);
+                // withTimeout races against Promise.all — if the timeout fires, the
+                // await resolves with an error but the underlying client.add() calls
+                // may still complete in the background. This is acceptable: the memory
+                // client API (Mem0) doesn't support AbortSignal, and these are
+                // fire-and-forget background writes where a stale completion is harmless.
+                await withTimeout(Promise.all(writeOps), 30_000, new Error("Background memory write timed out after 30s"));
             }
             catch (error) {
                 logger.warn("Memory storage failed:", error);
             }
         });
+        setImmediate(wrappedMemoryWrite);
     }
     /**
      * Set up HITL event forwarding to main emitter
@@ -3723,6 +3732,21 @@ Current user's request: ${currentInput}`;
             conversationMessageCount: conversationMessages.length,
             shouldCompact: budgetResult.shouldCompact,
         });
+        // Scale timeout for large contexts if caller didn't set one explicitly.
+        // Providers read options.timeout via getTimeout(), so setting it here
+        // propagates to any downstream provider call.
+        if (options.timeout === undefined &&
+            budgetResult.estimatedInputTokens > 100_000) {
+            // >100K → 1.5x, >200K → 2x, >300K → 2.5x (capped at 4x) of 60s base
+            const scale = 1 + Math.floor((budgetResult.estimatedInputTokens - 1) / 100_000) * 0.5;
+            const scaledMs = Math.round(60_000 * Math.min(scale, 4));
+            options.timeout = scaledMs;
+            logger.info("[TokenBudget] Scaled timeout for large context", {
+                requestId,
+                estimatedTokens: budgetResult.estimatedInputTokens,
+                scaledTimeoutMs: scaledMs,
+            });
+        }
         const compactionSessionId = this.getCompactionSessionId(options);
         const lastCompactionCount = this.lastCompactionMessageCount.get(compactionSessionId) ?? 0;
         if (!budgetResult.shouldCompact ||
@@ -3798,6 +3822,8 @@ Current user's request: ${currentInput}`;
             toolDefinitions: availableTools,
         });
         if (!finalBudget.withinBudget) {
+            // Clear watermark so handleContextOverflow recovery can re-compact
+            this.lastCompactionMessageCount.delete(compactionSessionId);
             throw new ContextBudgetExceededError(`Context exceeds model budget after all compaction stages. ` +
                 `Estimated: ${finalBudget.estimatedInputTokens} tokens, ` +
                 `Budget: ${finalBudget.availableInputTokens} tokens. ` +
@@ -3993,6 +4019,8 @@ Current user's request: ${currentInput}`;
                                 : undefined,
                         });
                         if (!finalBudget.withinBudget) {
+                            // Clear watermark so handleContextOverflow recovery can re-compact
+                            this.lastCompactionMessageCount.delete(dpgCompactionSessionId);
                             throw new ContextBudgetExceededError(`Context exceeds model budget after all compaction stages. ` +
                                 `Estimated: ${finalBudget.estimatedInputTokens} tokens, ` +
                                 `Budget: ${finalBudget.availableInputTokens} tokens.`, {
@@ -5016,6 +5044,8 @@ Current user's request: ${currentInput}`;
                     toolDefinitions: availableTools,
                 });
                 if (!finalBudget.withinBudget) {
+                    // Clear watermark so handleContextOverflow recovery can re-compact
+                    this.lastCompactionMessageCount.delete(streamCompactionSessionId);
                     throw new ContextBudgetExceededError(`Stream context exceeds model budget after all compaction stages. ` +
                         `Estimated: ${finalBudget.estimatedInputTokens} tokens, ` +
                         `Budget: ${finalBudget.availableInputTokens} tokens.`, {
@@ -7508,6 +7538,7 @@ Current user's request: ${currentInput}`;
                 // Emit server added event
                 this.emitter.emit("externalMCP:serverAdded", {
                     serverId,
+                    serverName: config.name || serverId,
                     config,
                     toolCount: result.metadata?.toolsDiscovered || 0,
                     timestamp: Date.now(),
@@ -7535,12 +7566,15 @@ Current user's request: ${currentInput}`;
         this.invalidateToolCache(); // Invalidate cache when an external server is removed
         try {
             mcpLogger.info(`[NeuroLink] Removing external MCP server: ${serverId}`);
+            // Capture the configured name before removal destroys the instance
+            const serverName = this.externalServerManager.getServerName(serverId);
             const result = await this.externalServerManager.removeServer(serverId);
             if (result.success) {
                 mcpLogger.info(`[NeuroLink] External MCP server removed successfully: ${serverId}`);
                 // Emit server removed event
                 this.emitter.emit("externalMCP:serverRemoved", {
                     serverId,
+                    serverName,
                     timestamp: Date.now(),
                 });
             }

package/dist/proxy/accountQuota.d.ts

@@ -16,6 +16,12 @@ import type { AccountQuota } from "../types/index.js";
  * Pure computation — no I/O, no blocking.
  */
 export declare function parseQuotaHeaders(headers: Headers | Record<string, string>): AccountQuota | null;
+/**
+ * Initialise the quota module with a custom file path.
+ * When set, all reads/writes go to this path instead of the default
+ * ~/.neurolink/account-quotas.json. Call before the first load/save.
+ */
+export declare function initAccountQuota(quotaFilePath: string): void;
 /**
  * Load all persisted account quotas.
  * First call reads from disk; subsequent calls return the in-memory cache.

package/dist/proxy/accountQuota.js

@@ -9,7 +9,7 @@
  * updates an in-memory cache and debounces disk writes so the request/response
  * path is never blocked by file I/O.
  */
-import { join } from "path";
+import { dirname, join } from "path";
 import { homedir } from "os";
 import { promises as fs } from "fs";
 // ---------------------------------------------------------------------------
@@ -73,11 +73,32 @@ let memoryCache = {};
 let cacheLoaded = false;
 let dirty = false;
 let flushTimer = null;
+/** Custom quota file path set via initAccountQuota(). */
+let customQuotaFilePath = null;
+/**
+ * Initialise the quota module with a custom file path.
+ * When set, all reads/writes go to this path instead of the default
+ * ~/.neurolink/account-quotas.json. Call before the first load/save.
+ */
+export function initAccountQuota(quotaFilePath) {
+    customQuotaFilePath = quotaFilePath;
+    // Cancel any pending flush from a previous configuration so it does not
+    // write stale data to the new path.
+    if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+    }
+    // Reset cache so the new path is picked up on next load
+    memoryCache = {};
+    cacheLoaded = false;
+    dirty = false;
+}
 function getQuotaFilePath() {
-    return join(homedir(), ".neurolink", QUOTA_FILE);
+    return customQuotaFilePath ?? join(homedir(), ".neurolink", QUOTA_FILE);
 }
 async function ensureDir() {
-    const dir = join(homedir(), ".neurolink");
+    const filePath = getQuotaFilePath();
+    const dir = dirname(filePath);
     await fs.mkdir(dir, { recursive: true, mode: 0o700 }).catch(() => {
         // Non-fatal: directory may already exist
     });

package/dist/proxy/proxyPaths.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Proxy file path resolver.
+ *
+ * In normal mode, all paths resolve under ~/.neurolink/.
+ * In dev mode (--dev), writable paths resolve under <cwd>/.neurolink-dev/
+ * so a local dev proxy never touches the global proxy's state.
+ *
+ * Read-only paths (like .env) always point to the global location
+ * since credentials must be shared.
+ *
+ * NOTE: Claude Code header snapshots (~/.neurolink/header-snapshots/) are
+ * not redirected in dev mode. They are only written when a real Claude Code
+ * client connects, which typically does not happen during dev testing.
+ */
+export type ProxyPaths = {
+    /** Base directory for proxy state files */
+    stateDir: string;
+    /** logs/ — request/response logs */
+    logsDir: string;
+    /** account-quotas.json — per-account rate limit state */
+    quotaFile: string;
+    /** Whether this is a dev-mode isolated instance */
+    isDev: boolean;
+};
+export declare function resolveProxyPaths(dev: boolean): ProxyPaths;

package/dist/proxy/proxyPaths.js

@@ -0,0 +1,34 @@
+/**
+ * Proxy file path resolver.
+ *
+ * In normal mode, all paths resolve under ~/.neurolink/.
+ * In dev mode (--dev), writable paths resolve under <cwd>/.neurolink-dev/
+ * so a local dev proxy never touches the global proxy's state.
+ *
+ * Read-only paths (like .env) always point to the global location
+ * since credentials must be shared.
+ *
+ * NOTE: Claude Code header snapshots (~/.neurolink/header-snapshots/) are
+ * not redirected in dev mode. They are only written when a real Claude Code
+ * client connects, which typically does not happen during dev testing.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function resolveProxyPaths(dev) {
+    if (dev) {
+        const base = join(process.cwd(), ".neurolink-dev");
+        return {
+            stateDir: base,
+            logsDir: join(base, "logs"),
+            quotaFile: join(base, "account-quotas.json"),
+            isDev: true,
+        };
+    }
+    const base = join(homedir(), ".neurolink");
+    return {
+        stateDir: base,
+        logsDir: join(base, "logs"),
+        quotaFile: join(base, "account-quotas.json"),
+        isDev: false,
+    };
+}

package/dist/proxy/requestLogger.d.ts

@@ -6,7 +6,7 @@
  * Useful for debugging and auditing proxy traffic.
  */
 import type { RequestAttemptLogEntry, RequestLogEntry } from "../types/index.js";
-export declare function initRequestLogger(enabled?: boolean): void;
+export declare function initRequestLogger(enabled?: boolean, customLogsDir?: string): void;
 export declare function logRequest(entry: RequestLogEntry): Promise<void>;
 /**
  * Log an upstream attempt separately from the final request outcome.

package/dist/proxy/requestLogger.js

@@ -44,13 +44,13 @@ const SENSITIVE_HEADER_NAMES = new Set([
 const SENSITIVE_HEADER_PATTERN = /token|secret|key|password|credential/i;
 /** JSON keys whose values should be redacted in request/response bodies. */
 const SENSITIVE_BODY_KEYS = /("(?:password|access_token|refresh_token|api_key|apiKey|secret|authorization|token|credential|x-api-key)"\s*:\s*)"(?:[^"\\]|\\.)*"/gi;
-export function initRequestLogger(enabled = true) {
+export function initRequestLogger(enabled = true, customLogsDir) {
     logEnabled = enabled;
     if (!enabled) {
         return;
     }
     try {
-        logDir = join(homedir(), ".neurolink", "logs");
+        logDir = customLogsDir ?? join(homedir(), ".neurolink", "logs");
         if (!existsSync(logDir)) {
             mkdirSync(logDir, { recursive: true, mode: 0o700 });
         }