@pnpm/auth.commands 1100.1.1 → 1100.1.2

package/lib/login.d.ts

@@ -32,12 +32,7 @@ export interface LoginFetchResponseHeaders {
 }
 export interface LoginFetchOptions {
     method?: 'GET' | 'POST' | 'PUT';
-    headers?: {
-        accept: 'application/json';
-        'content-type': 'application/json';
-        'npm-auth-type': 'web';
-        'npm-otp'?: string;
-    };
+    headers?: Record<string, string>;
     body?: string;
     retry?: {
         factor?: number;

package/lib/login.js

@@ -6,6 +6,7 @@ import { PnpmError } from '@pnpm/error';
 import { globalInfo, globalWarn } from '@pnpm/logger';
 import { fetch } from '@pnpm/network.fetch';
 import { generateQrCode, pollForWebAuthToken, promptBrowserOpen, SyntheticOtpError, withOtpHandling, } from '@pnpm/network.web-auth';
+import { addUser, AddUserHttpError, AddUserNoTokenError } from '@pnpm/registry-access.client';
 import enquirer from 'enquirer';
 import normalizeRegistryUrl from 'normalize-registry-url';
 import { readIniFile } from 'read-ini-file';
@@ -164,63 +165,38 @@ async function classicLogin({ context, fetchOptions, registry, }) {
     if (!username || !password || !email) {
         throw new LoginMissingCredentialsError();
     }
-    const loginUrl = new URL(`-/user/org.couchdb.user:${encodeURIComponent(username)}`, registry).href;
     const token = await withOtpHandling({
         context,
         fetchOptions,
         operation: async (otp) => {
-            const response = await fetch(loginUrl, {
-                method: 'PUT',
-                headers: {
-                    'content-type': 'application/json',
-                    accept: 'application/json',
-                    'npm-auth-type': 'web',
-                    // Conditionally include npm-otp: some HTTP implementations coerce
-                    // `undefined` to the string "undefined", which would send a bad header
-                    // on the initial attempt (before OTP is known).
-                    ...(otp != null ? { 'npm-otp': otp } : {}),
-                },
-                body: JSON.stringify({
-                    _id: `org.couchdb.user:${username}`,
-                    name: username,
+            try {
+                const result = await addUser({
+                    username,
                     password,
                     email,
-                    type: 'user',
-                }),
-            });
-            if (!response.ok) {
-                await throwIfOtpRequired(globalWarn, response);
-                const text = await response.text();
-                throw new ClassicLoginError(response.status, text);
+                    otp,
+                    registryUrl: registry,
+                    fetch,
+                });
+                return result.token;
             }
-            const body = await response.json();
-            if (!body.token) {
-                throw new LoginNoTokenError();
+            catch (err) {
+                if (err instanceof AddUserHttpError) {
+                    if (err.status === 401 && err.responseHeaders.get('www-authenticate')?.includes('otp')) {
+                        throw SyntheticOtpError.fromUnknownBody(globalWarn, err.responseJson);
+                    }
+                    throw new ClassicLoginError(err.status, err.responseText);
+                }
+                if (err instanceof AddUserNoTokenError) {
+                    throw new LoginNoTokenError();
+                }
+                throw err;
             }
-            return body.token;
         },
     });
     globalInfo(`Logged in as ${username}`);
     return token;
 }
-/**
- * Inspects a non-ok HTTP response for OTP requirements and throws an EOTP
- * error when detected. This mirrors the behaviour of npm-registry-fetch,
- * which checks the `www-authenticate` header for one-time password indicators.
- */
-async function throwIfOtpRequired(globalWarn, response) {
-    if (response.status !== 401)
-        return;
-    const wwwAuth = response.headers.get('www-authenticate');
-    if (!wwwAuth?.includes('otp'))
-        return;
-    let body;
-    try {
-        body = await response.json();
-    }
-    catch { }
-    throw SyntheticOtpError.fromUnknownBody(globalWarn, body);
-}
 class LoginNonInteractiveError extends PnpmError {
     constructor() {
         super('LOGIN_NON_INTERACTIVE', 'The login command requires an interactive terminal');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/auth.commands",
-  "version": "1100.1.1",
+  "version": "1100.1.2",
   "description": "Commands for authentication with npm registries",
   "keywords": [
     "pnpm",
@@ -30,18 +30,19 @@
     "read-ini-file": "5.0.0",
     "render-help": "^2.0.0",
     "write-ini-file": "5.0.0",
-    "@pnpm/cli.utils": "1101.0.7",
+    "@pnpm/cli.utils": "1101.0.8",
+    "@pnpm/config.reader": "1101.4.1",
+    "@pnpm/network.fetch": "1100.0.7",
     "@pnpm/error": "1100.0.0",
-    "@pnpm/network.web-auth": "1101.0.0",
-    "@pnpm/network.fetch": "1100.0.6",
-    "@pnpm/config.reader": "1101.4.0"
+    "@pnpm/registry-access.client": "1100.0.1",
+    "@pnpm/network.web-auth": "1101.0.0"
   },
   "peerDependencies": {
-    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+    "@pnpm/logger": "^1001.0.1"
   },
   "devDependencies": {
     "@jest/globals": "30.3.0",
-    "@pnpm/auth.commands": "1100.1.1",
+    "@pnpm/auth.commands": "1100.1.2",
     "@pnpm/logger": "1100.0.0"
   },
   "engines": {