@juspay/neurolink 13.8.16 → 13.8.18

package/dist/auth/anthropicOAuth.d.ts

@@ -331,7 +331,8 @@ export declare class AnthropicOAuth {
  * const tokens = await oauth.exchangeCodeForTokens(result.code, codeVerifier);
  * ```
  */
-export declare function startCallbackServer(port?: number, path?: string, timeout?: number): Promise<CallbackResult>;
+export declare function startCallbackServer(port?: number, path?: string, timeout?: number, // 5 minutes default
+expectedState?: string): Promise<CallbackResult>;
 /**
  * Stops the callback server if running
  * Note: The server automatically stops after receiving a callback or timing out
@@ -448,3 +449,27 @@ export declare function performOAuthFlow(oauth: AnthropicOAuth, options?: {
     /** Whether to automatically open browser (default: true) */
     openBrowser?: boolean;
 }): Promise<OAuthFlowTokens>;
+/**
+ * Split a pasted `code#state` string and bind it to the login in progress.
+ *
+ * The CLI paste flows used to set `state` to the PKCE verifier and then trust
+ * whatever the user pasted after `#` as that verifier, so the code was bound to
+ * nothing the CLI held: a phished `code#state` from someone else's login landed
+ * their account in the victim's pool. The state is now an unrelated random
+ * value, it must come back exactly, and the exchange always uses the verifier
+ * this process generated.
+ */
+export declare function parsePastedAuthorizationCode(pasted: string, expectedState: string): {
+    code: string;
+};
+/**
+ * Validate a pasted `code#state` against the login in progress and exchange it
+ * with the local verifier. Nothing is sent when the state does not match.
+ */
+export declare function exchangePastedSubscriptionCode(params: {
+    pasted: string;
+    expectedState: string;
+    codeVerifier: string;
+    clientId?: string;
+    redirectUri?: string;
+}): ReturnType<typeof exchangeSubscriptionCode>;

package/dist/auth/anthropicOAuth.js

@@ -914,7 +914,8 @@ export class AnthropicOAuth {
  * const tokens = await oauth.exchangeCodeForTokens(result.code, codeVerifier);
  * ```
  */
-export function startCallbackServer(port = DEFAULT_CALLBACK_PORT, path = "/callback", timeout = 5 * 60 * 1000) {
+export function startCallbackServer(port = DEFAULT_CALLBACK_PORT, path = "/callback", timeout = 5 * 60 * 1000, // 5 minutes default
+expectedState) {
     return new Promise((resolve, reject) => {
         let server = null;
         let timeoutId = null;
@@ -986,6 +987,26 @@ export function startCallbackServer(port = DEFAULT_CALLBACK_PORT, path = "/callb
                 reject(new OAuthCallbackServerError("No authorization code in callback"));
                 return;
             }
+            // A callback whose state is not ours is answered but never resolves the
+            // flow: on an all-interfaces listener that was how a LAN peer could abort
+            // a login or hand it a code of their choosing. The server keeps waiting
+            // for the genuine redirect.
+            if (expectedState !== undefined && state !== expectedState) {
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end(`
+          <!DOCTYPE html>
+          <html>
+            <head><title>State Mismatch</title></head>
+            <body>
+              <h1>Authentication Failed</h1>
+              <p>The callback did not match the login in progress.</p>
+              <p>You can close this window.</p>
+            </body>
+          </html>
+        `);
+                logger.warn("OAuth callback ignored: state mismatch");
+                return;
+            }
             // Success response
             res.writeHead(200, { "Content-Type": "text/html" });
             res.end(`
@@ -1010,8 +1031,10 @@ export function startCallbackServer(port = DEFAULT_CALLBACK_PORT, path = "/callb
             cleanup();
             reject(new OAuthCallbackServerError(`Failed to start callback server: ${error.message}`));
         });
-        server.listen(port, () => {
-            logger.info(`OAuth callback server listening on port ${port}`);
+        // Loopback only: the redirect comes from the operator's own browser, and an
+        // all-interfaces bind on a fixed port let anything on the network reach it.
+        server.listen(port, "127.0.0.1", () => {
+            logger.info(`OAuth callback server listening on 127.0.0.1:${port}`);
         });
     });
 }
@@ -1184,8 +1207,8 @@ export async function performOAuthFlow(oauth, options = {}) {
     const pkce = await AnthropicOAuth.generatePKCE();
     // Generate state for CSRF protection
     const state = randomBytes(32).toString("base64url");
-    // Start callback server
-    const callbackPromise = startCallbackServer(port, "/callback", timeout);
+    // Start callback server; it resolves only for a redirect carrying our state.
+    const callbackPromise = startCallbackServer(port, "/callback", timeout, state);
     // Generate auth URL
     const authUrl = oauth.generateAuthUrl({
         codeChallenge: pkce.codeChallenge,
@@ -1219,3 +1242,56 @@ export async function performOAuthFlow(oauth, options = {}) {
     const tokens = await oauth.exchangeCodeForTokens(callbackResult.code, pkce.codeVerifier);
     return tokens;
 }
+/**
+ * Split a pasted `code#state` string and bind it to the login in progress.
+ *
+ * The CLI paste flows used to set `state` to the PKCE verifier and then trust
+ * whatever the user pasted after `#` as that verifier, so the code was bound to
+ * nothing the CLI held: a phished `code#state` from someone else's login landed
+ * their account in the victim's pool. The state is now an unrelated random
+ * value, it must come back exactly, and the exchange always uses the verifier
+ * this process generated.
+ */
+export function parsePastedAuthorizationCode(pasted, expectedState) {
+    const trimmed = pasted.trim();
+    const separator = trimmed.indexOf("#");
+    const code = separator === -1 ? trimmed : trimmed.slice(0, separator);
+    const state = separator === -1 ? "" : trimmed.slice(separator + 1).trim();
+    if (!code) {
+        throw new OAuthError("Authorization code is empty. Paste the full code shown by the browser.", "INVALID_AUTHORIZATION_CODE");
+    }
+    if (!state) {
+        throw new OAuthError("Authorization code is missing its state. Paste the full code#state value " +
+            "the browser showed, from this login attempt.", "STATE_MISMATCH");
+    }
+    if (state.length !== expectedState.length ||
+        !timingSafeStringEqual(state, expectedState)) {
+        throw new OAuthError("Authorization code does not belong to this login attempt (state mismatch). " +
+            "Start the login again and paste only the code it produces.", "STATE_MISMATCH");
+    }
+    return { code };
+}
+function timingSafeStringEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    let difference = 0;
+    for (let index = 0; index < left.length; index += 1) {
+        difference |= left.charCodeAt(index) ^ right.charCodeAt(index);
+    }
+    return difference === 0;
+}
+/**
+ * Validate a pasted `code#state` against the login in progress and exchange it
+ * with the local verifier. Nothing is sent when the state does not match.
+ */
+export async function exchangePastedSubscriptionCode(params) {
+    const { code } = parsePastedAuthorizationCode(params.pasted, params.expectedState);
+    return exchangeSubscriptionCode({
+        code,
+        state: params.expectedState,
+        codeVerifier: params.codeVerifier,
+        ...(params.clientId ? { clientId: params.clientId } : {}),
+        ...(params.redirectUri ? { redirectUri: params.redirectUri } : {}),
+    });
+}

package/dist/auth/secureFiles.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Private file and directory creation for credential material.
+ *
+ * Every credential file under `~/.neurolink` used to be created through a
+ * different path with a different idea of permissions: a temp file at umask
+ * mode then chmod'd, a directory whose mode was asserted only on first
+ * creation, a truncate-in-place write that followed symlinks. These helpers
+ * are the one place that gets it right, and the token store, the CLI
+ * credentials file and the update-state file all go through them.
+ *
+ * @module auth/secureFiles
+ */
+export declare const PRIVATE_FILE_MODE = 384;
+export declare const PRIVATE_DIR_MODE = 448;
+/** Everything a CLI entry point creates is owner-only unless it says otherwise. */
+export declare const PRIVATE_UMASK = 63;
+/**
+ * Tighten the process umask so no file this process creates is group- or
+ * world-readable, whatever the shell's default was. Idempotent; returns the
+ * mask that was in force.
+ */
+export declare function tightenProcessUmask(): number;
+/** Create `dir` owner-only, and re-assert the mode when it already existed. */
+export declare function ensurePrivateDirectory(dir: string): Promise<void>;
+/** Synchronous twin of {@link ensurePrivateDirectory}, for CLI start-up paths. */
+export declare function ensurePrivateDirectorySync(dir: string): void;
+/**
+ * Write `content` to `targetPath` atomically and owner-only.
+ *
+ * The temp file is created with `wx` at 0600 — never at umask mode and then
+ * chmod'd, which left a window in which another uid could open it — under an
+ * unpredictable name, and renamed into place. A rename replaces a symlink at
+ * the target rather than following it.
+ */
+export declare function writePrivateFileAtomically(targetPath: string, content: string): Promise<void>;
+/** Synchronous twin of {@link writePrivateFileAtomically}. */
+export declare function writePrivateFileAtomicallySync(targetPath: string, content: string): void;

package/dist/auth/secureFiles.js

@@ -0,0 +1,95 @@
+/**
+ * Private file and directory creation for credential material.
+ *
+ * Every credential file under `~/.neurolink` used to be created through a
+ * different path with a different idea of permissions: a temp file at umask
+ * mode then chmod'd, a directory whose mode was asserted only on first
+ * creation, a truncate-in-place write that followed symlinks. These helpers
+ * are the one place that gets it right, and the token store, the CLI
+ * credentials file and the update-state file all go through them.
+ *
+ * @module auth/secureFiles
+ */
+import { randomUUID } from "node:crypto";
+import { chmodSync, mkdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { chmod, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export const PRIVATE_FILE_MODE = 0o600;
+export const PRIVATE_DIR_MODE = 0o700;
+/** Everything a CLI entry point creates is owner-only unless it says otherwise. */
+export const PRIVATE_UMASK = 0o077;
+/**
+ * Tighten the process umask so no file this process creates is group- or
+ * world-readable, whatever the shell's default was. Idempotent; returns the
+ * mask that was in force.
+ */
+export function tightenProcessUmask() {
+    if (process.platform === "win32") {
+        return 0;
+    }
+    return process.umask(PRIVATE_UMASK);
+}
+/** Create `dir` owner-only, and re-assert the mode when it already existed. */
+export async function ensurePrivateDirectory(dir) {
+    await mkdir(dir, { recursive: true, mode: PRIVATE_DIR_MODE });
+    await chmod(dir, PRIVATE_DIR_MODE).catch(() => undefined);
+}
+/** Synchronous twin of {@link ensurePrivateDirectory}, for CLI start-up paths. */
+export function ensurePrivateDirectorySync(dir) {
+    mkdirSync(dir, { recursive: true, mode: PRIVATE_DIR_MODE });
+    try {
+        chmodSync(dir, PRIVATE_DIR_MODE);
+    }
+    catch {
+        // Not owned by us; the mkdir above is the best we can do.
+    }
+}
+function tempPathFor(targetPath) {
+    return `${targetPath}.tmp.${process.pid}.${randomUUID()}`;
+}
+/**
+ * Write `content` to `targetPath` atomically and owner-only.
+ *
+ * The temp file is created with `wx` at 0600 — never at umask mode and then
+ * chmod'd, which left a window in which another uid could open it — under an
+ * unpredictable name, and renamed into place. A rename replaces a symlink at
+ * the target rather than following it.
+ */
+export async function writePrivateFileAtomically(targetPath, content) {
+    await ensurePrivateDirectory(dirname(targetPath));
+    const tempPath = tempPathFor(targetPath);
+    try {
+        await writeFile(tempPath, content, {
+            encoding: "utf8",
+            mode: PRIVATE_FILE_MODE,
+            flag: "wx",
+        });
+        await chmod(tempPath, PRIVATE_FILE_MODE).catch(() => undefined);
+        await rename(tempPath, targetPath);
+    }
+    finally {
+        await rm(tempPath, { force: true }).catch(() => undefined);
+    }
+}
+/** Synchronous twin of {@link writePrivateFileAtomically}. */
+export function writePrivateFileAtomicallySync(targetPath, content) {
+    ensurePrivateDirectorySync(dirname(targetPath));
+    const tempPath = tempPathFor(targetPath);
+    try {
+        writeFileSync(tempPath, content, {
+            encoding: "utf8",
+            mode: PRIVATE_FILE_MODE,
+            flag: "wx",
+        });
+        try {
+            chmodSync(tempPath, PRIVATE_FILE_MODE);
+        }
+        catch {
+            // The create mode already bounded it.
+        }
+        renameSync(tempPath, targetPath);
+    }
+    finally {
+        rmSync(tempPath, { force: true });
+    }
+}

package/dist/auth/tokenStore.d.ts

@@ -50,12 +50,12 @@ export declare class TokenStore {
     private static readonly NEUROLINK_DIR;
     private static readonly TOKEN_FILE;
     private static readonly FILE_PERMISSIONS;
-    private static readonly DIR_PERMISSIONS;
     /** Default expiration buffer: 1 hour (proactive refresh before actual expiry) */
     private static readonly DEFAULT_EXPIRY_BUFFER_MS;
     private readonly storagePath;
     private readonly encryptionEnabled;
     private readonly encryptionKey;
+    private readonly encryptionKeyBytes;
     private readonly tokenRefreshers;
     private readonly inFlightRefreshes;
     private readonly _mutex;
@@ -246,10 +246,44 @@ export declare class TokenStore {
      * Loads the storage data from file
      */
     private loadStorageData;
+    /** Parse plain-JSON storage; null when it is not a usable store. */
+    private parseStorageJson;
+    /**
+     * Decode a store written by either codec.
+     *
+     * The current codec is prefixed and XORs UTF-8 bytes. The older one XORed
+     * UTF-16 code units and then truncated each to a byte, so a store holding a
+     * single non-Latin-1 character (an emoji in a label, a smart quote in a
+     * disable reason) could never be read back. Older files carry no prefix and
+     * are read the old way; the next save rewrites them with the new codec.
+     */
+    private parseObfuscatedStorage;
+    private quarantineStorageFile;
     /**
      * Saves storage data to file
      */
     private saveStorageData;
+    /**
+     * Serialize and write the store: owner-only from creation, under an
+     * unpredictable temp name, renamed into place. See `secureFiles`.
+     */
+    private writeStorageFile;
+    /**
+     * Take the in-process mutex, then the cross-process file lock, around a
+     * read-modify-write. The CLI and a running proxy share one file; without
+     * the second lock a stale snapshot written late reverted the other's
+     * rotated refresh token or disable flag.
+     */
+    private runExclusiveLocked;
+    private get lockPath();
+    private readLockOwner;
+    private removeAbandonedLock;
+    /**
+     * Best-effort cross-process lock. When another process holds it past the
+     * timeout the write proceeds anyway with a warning: a stuck lock must not
+     * take the pool offline, which is worse than the race it guards against.
+     */
+    private acquireFileLock;
     /**
      * Deletes the storage file
      */
@@ -268,16 +302,19 @@ export declare class TokenStore {
      * using proper encryption with a user-provided key or system keychain
      */
     private deriveEncryptionKey;
+    private deriveEncryptionKeyBytes;
     /**
-     * Simple XOR-based obfuscation
-     * Note: This is NOT cryptographically secure, just basic obfuscation
-     * For production use, consider using node:crypto with proper encryption
+     * XOR obfuscation over the UTF-8 bytes of the document, base64-encoded and
+     * prefixed so a reader can tell it from the older code-unit codec.
+     * Note: this is NOT cryptographically secure, just basic obfuscation.
      */
     private obfuscate;
+    private deobfuscateV2;
     /**
-     * Reverses the XOR obfuscation
+     * The pre-UTF-8 codec, kept only to read stores written before it existed.
+     * It cannot round-trip any character above U+00FF.
      */
-    private deobfuscate;
+    private deobfuscateLegacy;
 }
 /**
  * Default token store singleton instance