chrome-webstore-upload 4.0.1 → 4.0.2

package/distribution/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class CWSError extends Error {
+    cause: unknown;
+    name: string;
+}
+export declare function throwIfNotOk(request: Response, response: unknown): void;

package/distribution/errors.js

@@ -0,0 +1,42 @@
+export class CWSError extends Error {
+    cause;
+    name = 'CWSError';
+}
+function parseErrorMessage(response) {
+    const errorResponse = response;
+    // Handle OAuth errors: { error: "invalid_grant", error_description: "Bad Request" }
+    if (typeof errorResponse.error === 'string') {
+        if (errorResponse.error === 'invalid_grant') {
+            return 'Invalid grant: The authentication keys are probably invalid or expired';
+        }
+        if (errorResponse.error === 'invalid_request') {
+            return `Invalid request: ${errorResponse.error_description ?? 'Missing required parameters'}`;
+        }
+        return errorResponse.error_description ?? errorResponse.error;
+    }
+    // Handle API errors: { error: { code: 400, message: "...", errors: [...] } }
+    if (errorResponse.error && typeof errorResponse.error === 'object') {
+        const { error } = errorResponse;
+        if (error.message) {
+            // Remove "Publish condition not met: " prefix if present
+            return error.message.replace(/^Publish condition not met: /, '');
+        }
+    }
+    // Handle item errors in ItemResource: { itemError: [{ error_code: "...", error_detail: "..." }] }
+    const itemResource = response;
+    if (itemResource.itemError && Array.isArray(itemResource.itemError) && itemResource.itemError.length > 0) {
+        const errorDetails = itemResource.itemError.map(error => error.error_detail).join('; ');
+        return errorDetails;
+    }
+    return 'Unknown error';
+}
+export function throwIfNotOk(request, response) {
+    // Check for upload failure even on HTTP 200
+    const itemResource = response;
+    if (!request.ok || itemResource.uploadState === 'FAILURE') {
+        const message = parseErrorMessage(response);
+        const error = new CWSError(message);
+        error.cause = response;
+        throw error;
+    }
+}

package/distribution/index.d.ts

@@ -0,0 +1,22 @@
+import { type ReadStream } from 'node:fs';
+import type { APIClientOptions, ItemResource, PublishResponse } from './types.js';
+export declare const refreshTokenURI = "https://www.googleapis.com/oauth2/v4/token";
+export type { APIClientOptions, ItemResource, PublishResponse } from './types.js';
+export { CWSError } from './errors.js';
+declare class APIClient {
+    extensionId: string;
+    clientId: string;
+    refreshToken: string;
+    clientSecret: string | undefined;
+    constructor(options: APIClientOptions);
+    uploadExisting(streamOrPath: ReadStream | ReadableStream | string, token?: string | Promise<string>, maxAwaitInProgressResponseSeconds?: number): Promise<ItemResource>;
+    publish(target?: string, token?: string | Promise<string>, deployPercentage?: number | undefined): Promise<PublishResponse>;
+    get(projection?: string, token?: string | Promise<string>): Promise<ItemResource>;
+    fetchToken(): Promise<string>;
+    _waitUploadSuccess(response: ItemResource, maxAwaitInProgressResponseSeconds: number): Promise<ItemResource>;
+    _headers(token: string): {
+        Authorization: string;
+        'x-goog-api-version': string;
+    };
+}
+export default function chromeWebstoreUpload(options: APIClientOptions): APIClient;

package/distribution/index.js

@@ -0,0 +1,133 @@
+// API documentation:
+// https://developer.chrome.com/docs/webstore/api
+// https://developer.chrome.com/docs/webstore/using-api
+import fs from 'node:fs';
+import { throwIfNotOk } from './errors.js';
+import zipStreamFromDirectory from './zip-dir.js';
+const rootURI = 'https://www.googleapis.com';
+export const refreshTokenURI = 'https://www.googleapis.com/oauth2/v4/token';
+const uploadExistingURI = (id) => `${rootURI}/upload/chromewebstore/v1.1/items/${id}`;
+const publishURI = ({ extensionId, target = 'default', deployPercentage }) => {
+    const url = new URL(`${rootURI}/chromewebstore/v1.1/items/${extensionId}/publish`);
+    url.searchParams.set('publishTarget', target);
+    if (deployPercentage !== undefined) {
+        url.searchParams.set('deployPercentage', String(deployPercentage));
+    }
+    return url.href;
+};
+const getURI = (id, projection) => `${rootURI}/chromewebstore/v1.1/items/${id}?projection=${projection}`;
+const requiredFields = ['extensionId', 'clientId', 'refreshToken'];
+const retryIntervalSeconds = 2;
+async function getStreamFromPath(filepath) {
+    const stats = await fs.promises.stat(filepath);
+    return stats.isFile()
+        ? fs.createReadStream(filepath)
+        : zipStreamFromDirectory(filepath);
+}
+export { CWSError } from './errors.js';
+class APIClient {
+    extensionId;
+    clientId;
+    refreshToken;
+    clientSecret;
+    constructor(options) {
+        if (typeof fetch !== 'function') {
+            throw new TypeError('`chrome-webstore-upload` requires Node.js 18.17 or newer because it relies on the global `fetch` function.');
+        }
+        if (typeof options !== 'object') {
+            throw new TypeError('The options object is required');
+        }
+        for (const field of requiredFields) {
+            if (!options[field]) {
+                throw new Error(`Option "${field}" is required`);
+            }
+        }
+        this.extensionId = options.extensionId;
+        this.clientId = options.clientId;
+        this.refreshToken = options.refreshToken;
+        this.clientSecret = options.clientSecret;
+    }
+    async uploadExisting(streamOrPath, token = this.fetchToken(), maxAwaitInProgressResponseSeconds = 0) {
+        if (!streamOrPath) {
+            throw new Error('Read stream missing');
+        }
+        // Convert string path (file or directory) to stream
+        const readStream = typeof streamOrPath === 'string'
+            ? await getStreamFromPath(streamOrPath)
+            : streamOrPath;
+        const { extensionId } = this;
+        const request = await fetch(uploadExistingURI(extensionId), {
+            method: 'PUT',
+            headers: this._headers(await token),
+            // @ts-expect-error Node extension? 🤷‍♂️ Required https://github.com/nodejs/node/issues/46221
+            duplex: 'half',
+            // Until they figure it out, this seems to work. Alternatively use https://stackoverflow.com/a/76780381/288906
+            body: readStream,
+        });
+        const response = await request.json();
+        throwIfNotOk(request, response);
+        return this._waitUploadSuccess(response, maxAwaitInProgressResponseSeconds);
+    }
+    async publish(target = 'default', token = this.fetchToken(), deployPercentage = undefined) {
+        const { extensionId } = this;
+        const request = await fetch(publishURI({ extensionId, target, deployPercentage }), {
+            method: 'POST',
+            headers: this._headers(await token),
+        });
+        const response = await request.json();
+        throwIfNotOk(request, response);
+        return response;
+    }
+    async get(projection = 'DRAFT', token = this.fetchToken()) {
+        const { extensionId } = this;
+        const request = await fetch(getURI(extensionId, projection), {
+            method: 'GET',
+            headers: this._headers(await token),
+        });
+        const response = await request.json();
+        throwIfNotOk(request, response);
+        return response;
+    }
+    async fetchToken() {
+        const { clientId, clientSecret, refreshToken } = this;
+        const json = {
+            client_id: clientId,
+            refresh_token: refreshToken,
+            grant_type: 'refresh_token',
+            client_secret: clientSecret,
+        };
+        if (!clientSecret) {
+            delete json.client_secret;
+        }
+        const request = await fetch(refreshTokenURI, {
+            method: 'POST',
+            body: JSON.stringify(json),
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        const response = await request.json();
+        throwIfNotOk(request, response);
+        return response.access_token;
+    }
+    async _waitUploadSuccess(response, maxAwaitInProgressResponseSeconds) {
+        if (response.uploadState !== 'IN_PROGRESS' || maxAwaitInProgressResponseSeconds < retryIntervalSeconds) {
+            return response;
+        }
+        // Wait before checking again
+        await new Promise(resolve => {
+            setTimeout(resolve, retryIntervalSeconds * 1000);
+        });
+        // Retry fetching the item resource
+        return this._waitUploadSuccess(await this.get('DRAFT'), maxAwaitInProgressResponseSeconds - retryIntervalSeconds);
+    }
+    _headers(token) {
+        return {
+            Authorization: `Bearer ${token}`,
+            'x-goog-api-version': '2',
+        };
+    }
+}
+export default function chromeWebstoreUpload(options) {
+    return new APIClient(options);
+}

package/distribution/types.d.ts

@@ -0,0 +1,22 @@
+export type APIClientOptions = {
+    extensionId: string;
+    clientId: string;
+    refreshToken: string;
+    clientSecret: string | undefined;
+};
+export type ItemResource = {
+    kind: 'chromewebstore#item';
+    id: string;
+    publicKey: string;
+    uploadState: 'FAILURE' | 'IN_PROGRESS' | 'NOT_FOUND' | 'SUCCESS';
+    itemError: Array<{
+        error_code: string;
+        error_detail: string;
+    }>;
+};
+export type PublishResponse = {
+    kind: 'chromewebstore#item';
+    item_id: string;
+    status: Array<'OK' | 'NOT_AUTHORIZED' | 'INVALID_DEVELOPER' | 'DEVELOPER_NO_OWNERSHIP' | 'DEVELOPER_SUSPENDED' | 'ITEM_NOT_FOUND' | 'ITEM_PENDING_REVIEW' | 'ITEM_TAKEN_DOWN' | 'PUBLISHER_SUSPENDED'>;
+    statusDetail: string[];
+};

package/distribution/types.js

@@ -0,0 +1 @@
+export {};

package/distribution/zip-dir.d.ts

@@ -0,0 +1 @@
+export default function zipStreamFromDirectory(directory: string): Promise<NodeJS.ReadableStream>;

package/distribution/zip-dir.js

@@ -0,0 +1,17 @@
+import { readdir } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { isNotJunk } from 'junk';
+import yazl from 'yazl';
+export default async function zipStreamFromDirectory(directory) {
+    const allFiles = await readdir(directory, { recursive: true });
+    const files = allFiles.filter(file => isNotJunk(basename(file)));
+    if (!files.includes('manifest.json')) {
+        throw new Error(`manifest.json was not found in ${directory}`);
+    }
+    const zip = new yazl.ZipFile();
+    for (const file of files) {
+        zip.addFile(join(directory, file), file);
+    }
+    zip.end();
+    return zip.outputStream;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-webstore-upload",
-  "version": "4.0.1",
+  "version": "4.0.2",
   "description": "Upload Chrome Extensions to the Chrome Web Store",
   "keywords": [
     "chrome",
@@ -42,34 +42,29 @@
       "object-curly-spacing": [
         "error",
         "always"
+      ],
+      "@typescript-eslint/naming-convention": "off",
+      "@stylistic/object-curly-spacing": [
+        "error",
+        "always"
+      ],
+      "@stylistic/block-spacing": [
+        "error",
+        "always"
       ]
     },
-    "overrides": [
-      {
-        "files": [
-          "**/*.ts"
-        ],
-        "rules": {
-          "@typescript-eslint/naming-convention": "off",
-          "@typescript-eslint/object-curly-spacing": [
-            "error",
-            "always"
-          ]
-        }
-      }
-    ],
     "space": 4
   },
   "devDependencies": {
-    "@sindresorhus/tsconfig": "^5.0.0",
+    "@sindresorhus/tsconfig": "^8.0.1",
     "@types/yazl": "^3.3.0",
     "dot-json": "^1.3.0",
     "fetch-mock": "^9.11.0",
     "node-fetch": "^2.7.0",
-    "typescript": "^5.3.3",
+    "typescript": "^5.9.3",
     "utc-version": "^2.0.2",
     "vitest": "^3.2.4",
-    "xo": "^0.58.0"
+    "xo": "^1.2.3"
   },
   "engines": {
     "node": ">=20"