@vscode/vsce 2.15.0

package/out/publicgalleryapi.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicGalleryAPI = void 0;
+const HttpClient_1 = require("typed-rest-client/HttpClient");
+const GalleryInterfaces_1 = require("azure-devops-node-api/interfaces/GalleryInterfaces");
+const Serialization_1 = require("azure-devops-node-api/Serialization");
+class PublicGalleryAPI {
+    constructor(baseUrl, apiVersion = '3.0-preview.1') {
+        this.baseUrl = baseUrl;
+        this.apiVersion = apiVersion;
+        this.client = new HttpClient_1.HttpClient('vsce');
+    }
+    post(url, data, additionalHeaders) {
+        return this.client.post(`${this.baseUrl}/_apis/public${url}`, data, additionalHeaders);
+    }
+    async extensionQuery({ pageNumber = 1, pageSize = 1, flags = [], criteria = [], assetTypes = [], }) {
+        const data = JSON.stringify({
+            filters: [{ pageNumber, pageSize, criteria }],
+            assetTypes,
+            flags: flags.reduce((memo, flag) => memo | flag, 0),
+        });
+        const res = await this.post('/gallery/extensionquery', data, {
+            Accept: `application/json;api-version=${this.apiVersion}`,
+            'Content-Type': 'application/json',
+        });
+        const raw = JSON.parse(await res.readBody());
+        if (raw.errorCode !== undefined) {
+            throw new Error(raw.message);
+        }
+        return Serialization_1.ContractSerializer.deserialize(raw.results[0].extensions, GalleryInterfaces_1.TypeInfo.PublishedExtension, false, false);
+    }
+    async getExtension(extensionId, flags = []) {
+        const query = { criteria: [{ filterType: GalleryInterfaces_1.ExtensionQueryFilterType.Name, value: extensionId }], flags };
+        const extensions = await this.extensionQuery(query);
+        return extensions.filter(({ publisher: { publisherName: publisher }, extensionName: name }) => extensionId.toLowerCase() === `${publisher}.${name}`.toLowerCase())[0];
+    }
+}
+exports.PublicGalleryAPI = PublicGalleryAPI;
+//# sourceMappingURL=publicgalleryapi.js.map

package/out/publish.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpublish = exports.publish = void 0;
+const fs = __importStar(require("fs"));
+const util_1 = require("util");
+const semver = __importStar(require("semver"));
+const GalleryInterfaces_1 = require("azure-devops-node-api/interfaces/GalleryInterfaces");
+const package_1 = require("./package");
+const tmp = __importStar(require("tmp"));
+const store_1 = require("./store");
+const util_2 = require("./util");
+const zip_1 = require("./zip");
+const validation_1 = require("./validation");
+const tmpName = (0, util_1.promisify)(tmp.tmpName);
+async function publish(options = {}) {
+    if (options.packagePath) {
+        if (options.version) {
+            throw new Error(`Both options not supported simultaneously: 'packagePath' and 'version'.`);
+        }
+        else if (options.targets) {
+            throw new Error(`Both options not supported simultaneously: 'packagePath' and 'target'. Use 'vsce package --target <target>' to first create a platform specific package, then use 'vsce publish --packagePath <path>' to publish it.`);
+        }
+        for (const packagePath of options.packagePath) {
+            const vsix = await (0, zip_1.readVSIXPackage)(packagePath);
+            let target;
+            try {
+                target = vsix.xmlManifest.PackageManifest.Metadata[0].Identity[0].$.TargetPlatform ?? undefined;
+            }
+            catch (err) {
+                throw new Error(`Invalid extension VSIX manifest. ${err}`);
+            }
+            if (options.preRelease) {
+                let isPreReleasePackage = false;
+                try {
+                    isPreReleasePackage = !!vsix.xmlManifest.PackageManifest.Metadata[0].Properties[0].Property.some(p => p.$.Id === 'Microsoft.VisualStudio.Code.PreRelease');
+                }
+                catch (err) {
+                    throw new Error(`Invalid extension VSIX manifest. ${err}`);
+                }
+                if (!isPreReleasePackage) {
+                    throw new Error(`Cannot use '--pre-release' flag with a package that was not packaged as pre-release. Please package it using the '--pre-release' flag and publish again.`);
+                }
+            }
+            await _publish(packagePath, vsix.manifest, { ...options, target });
+        }
+    }
+    else {
+        const cwd = options.cwd || process.cwd();
+        const manifest = await (0, package_1.readManifest)(cwd);
+        (0, util_2.patchOptionsWithManifest)(options, manifest);
+        await (0, package_1.prepublish)(cwd, manifest, options.useYarn);
+        await (0, package_1.versionBump)(options);
+        if (options.targets) {
+            for (const target of options.targets) {
+                const packagePath = await tmpName();
+                const packageResult = await (0, package_1.pack)({ ...options, target, packagePath });
+                await _publish(packagePath, packageResult.manifest, { ...options, target });
+            }
+        }
+        else {
+            const packagePath = await tmpName();
+            const packageResult = await (0, package_1.pack)({ ...options, packagePath });
+            await _publish(packagePath, packageResult.manifest, options);
+        }
+    }
+}
+exports.publish = publish;
+async function _publish(packagePath, manifest, options) {
+    (0, validation_1.validatePublisher)(manifest.publisher);
+    if (!options.noVerify && manifest.enableProposedApi) {
+        throw new Error("Extensions using proposed API (enableProposedApi: true) can't be published to the Marketplace");
+    }
+    if (!options.noVerify && manifest.enabledApiProposals) {
+        throw new Error("Extensions using proposed API (enabledApiProposals: [...]) can't be published to the Marketplace");
+    }
+    if (semver.prerelease(manifest.version)) {
+        throw new Error(`The VS Marketplace doesn't support prerelease versions: '${manifest.version}'`);
+    }
+    const pat = options.pat ?? (await (0, store_1.getPublisher)(manifest.publisher)).pat;
+    const api = await (0, util_2.getGalleryAPI)(pat);
+    const packageStream = fs.createReadStream(packagePath);
+    const name = `${manifest.publisher}.${manifest.name}`;
+    const description = options.target
+        ? `${name} (${options.target}) v${manifest.version}`
+        : `${name} v${manifest.version}`;
+    util_2.log.info(`Publishing '${description}'...`);
+    let extension = null;
+    try {
+        try {
+            extension = await api.getExtension(null, manifest.publisher, manifest.name, undefined, GalleryInterfaces_1.ExtensionQueryFlags.IncludeVersions);
+        }
+        catch (err) {
+            if (err.statusCode !== 404) {
+                throw err;
+            }
+        }
+        if (extension && extension.versions) {
+            const sameVersion = extension.versions.filter(v => v.version === manifest.version);
+            if (sameVersion.length > 0) {
+                if (options.skipDuplicate) {
+                    util_2.log.done(`Version ${manifest.version} is already published. Skipping publish.`);
+                    return;
+                }
+                if (sameVersion.some(v => v.targetPlatform === options.target)) {
+                    throw new Error(`${description} already exists.`);
+                }
+            }
+            try {
+                await api.updateExtension(undefined, packageStream, manifest.publisher, manifest.name);
+            }
+            catch (err) {
+                if (err.statusCode === 409) {
+                    if (options.skipDuplicate) {
+                        util_2.log.done(`Version ${manifest.version} is already published. Skipping publish.`);
+                        return;
+                    }
+                    else {
+                        throw new Error(`${description} already exists.`);
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        else {
+            await api.createExtension(undefined, packageStream);
+        }
+    }
+    catch (err) {
+        const message = (err && err.message) || '';
+        if (/Personal Access Token used has expired/.test(message)) {
+            err.message = `${err.message}\n\nYou're using an expired Personal Access Token, please get a new PAT.\nMore info: https://aka.ms/vscodepat`;
+        }
+        else if (/Invalid Resource/.test(message)) {
+            err.message = `${err.message}\n\nYou're likely using an expired Personal Access Token, please get a new PAT.\nMore info: https://aka.ms/vscodepat`;
+        }
+        throw err;
+    }
+    util_2.log.info(`Extension URL (might take a few minutes): ${(0, util_2.getPublishedUrl)(name)}`);
+    util_2.log.info(`Hub URL: ${(0, util_2.getHubUrl)(manifest.publisher, manifest.name)}`);
+    util_2.log.done(`Published ${description}.`);
+}
+async function unpublish(options = {}) {
+    let publisher, name;
+    if (options.id) {
+        [publisher, name] = options.id.split('.');
+    }
+    else {
+        const manifest = await (0, package_1.readManifest)(options.cwd);
+        publisher = manifest.publisher;
+        name = manifest.name;
+    }
+    const fullName = `${publisher}.${name}`;
+    if (!options.force) {
+        const answer = await (0, util_2.read)(`This will delete ALL published versions! Please type '${fullName}' to confirm: `);
+        if (answer !== fullName) {
+            throw new Error('Aborted');
+        }
+    }
+    const pat = options.pat ?? (await (0, store_1.getPublisher)(publisher)).pat;
+    const api = await (0, util_2.getGalleryAPI)(pat);
+    await api.deleteExtension(publisher, name);
+    util_2.log.done(`Deleted extension: ${fullName}!`);
+}
+exports.unpublish = unpublish;
+//# sourceMappingURL=publish.js.map

package/out/search.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.search = void 0;
+const util_1 = require("./util");
+const GalleryInterfaces_1 = require("azure-devops-node-api/interfaces/GalleryInterfaces");
+const viewutils_1 = require("./viewutils");
+const installationTarget = 'Microsoft.VisualStudio.Code';
+const excludeFlags = '37888'; //Value to exclude un-published, locked or hidden extensions
+const baseResultsTableHeaders = ['<ExtensionId>', '<Publisher>', '<Name>'];
+async function search(searchText, json = false, pageSize = 10, stats = false) {
+    const api = (0, util_1.getPublicGalleryAPI)();
+    const results = (await api.extensionQuery({
+        pageSize,
+        criteria: [
+            { filterType: GalleryInterfaces_1.ExtensionQueryFilterType.SearchText, value: searchText },
+            { filterType: GalleryInterfaces_1.ExtensionQueryFilterType.InstallationTarget, value: installationTarget },
+            { filterType: GalleryInterfaces_1.ExtensionQueryFilterType.ExcludeWithFlags, value: excludeFlags },
+        ],
+        flags: [
+            GalleryInterfaces_1.ExtensionQueryFlags.ExcludeNonValidated,
+            GalleryInterfaces_1.ExtensionQueryFlags.IncludeLatestVersionOnly,
+            stats ? GalleryInterfaces_1.ExtensionQueryFlags.IncludeStatistics : 0,
+        ],
+    }));
+    if (stats || !json) {
+        console.log([
+            `Search results:`,
+            '',
+            ...buildResultTableView(results, stats),
+            '',
+            'For more information on an extension use "vsce show <extensionId>"',
+        ]
+            .map(line => (0, viewutils_1.wordTrim)(line.replace(/\s+$/g, '')))
+            .join('\n'));
+        return;
+    }
+    if (!results.length) {
+        console.log('No matching results');
+        return;
+    }
+    if (json) {
+        console.log(JSON.stringify(results, undefined, '\t'));
+        return;
+    }
+}
+exports.search = search;
+function buildResultTableView(results, stats) {
+    const values = results.map(({ publisher, extensionName, displayName, shortDescription, statistics }) => [
+        publisher.publisherName + '.' + extensionName,
+        publisher.displayName,
+        (0, viewutils_1.wordTrim)(displayName || '', 25),
+        stats ? buildExtensionStatisticsText(statistics) : (0, viewutils_1.wordTrim)(shortDescription || '', 150).replace(/\n|\r|\t/g, ' '),
+    ]);
+    var resultsTableHeaders = stats
+        ? [...baseResultsTableHeaders, '<Installs>', '<Rating>']
+        : [...baseResultsTableHeaders, '<Description>'];
+    const resultsTable = (0, viewutils_1.tableView)([resultsTableHeaders, ...values]);
+    return resultsTable;
+}
+function buildExtensionStatisticsText(statistics) {
+    const { install: installs = 0, averagerating = 0, ratingcount = 0 } = statistics?.reduce((map, { statisticName, value }) => ({ ...map, [statisticName]: value }), {});
+    return (`${Number(installs).toLocaleString('en-US').padStart(12, ' ')} \t\t` +
+        ` ${(0, viewutils_1.ratingStars)(averagerating).padEnd(3, ' ')} (${ratingcount})`);
+}
+//# sourceMappingURL=search.js.map

package/out/show.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.show = void 0;
+const util_1 = require("./util");
+const GalleryInterfaces_1 = require("azure-devops-node-api/interfaces/GalleryInterfaces");
+const viewutils_1 = require("./viewutils");
+const limitVersions = 6;
+const isExtensionTag = /^__ext_(.*)$/;
+function show(extensionId, json = false) {
+    const flags = [
+        GalleryInterfaces_1.ExtensionQueryFlags.IncludeCategoryAndTags,
+        GalleryInterfaces_1.ExtensionQueryFlags.IncludeMetadata,
+        GalleryInterfaces_1.ExtensionQueryFlags.IncludeStatistics,
+        GalleryInterfaces_1.ExtensionQueryFlags.IncludeVersions,
+    ];
+    return (0, util_1.getPublicGalleryAPI)()
+        .getExtension(extensionId, flags)
+        .then(extension => {
+        if (json) {
+            console.log(JSON.stringify(extension, undefined, '\t'));
+        }
+        else {
+            if (extension === undefined) {
+                util_1.log.error(`Extension "${extensionId}" not found.`);
+            }
+            else {
+                showOverview(extension);
+            }
+        }
+    });
+}
+exports.show = show;
+function showOverview({ displayName = 'unknown', extensionName = 'unknown', shortDescription = '', versions = [], publisher: { displayName: publisherDisplayName, publisherName }, categories = [], tags = [], statistics = [], publishedDate, lastUpdated, }) {
+    const [{ version = 'unknown' } = {}] = versions;
+    // Create formatted table list of versions
+    const versionList = (versions.slice(0, limitVersions).map(({ version, lastUpdated }) => [version, (0, viewutils_1.formatDate)(lastUpdated)]));
+    const { install: installs = 0, averagerating = 0, ratingcount = 0 } = statistics.reduce((map, { statisticName, value }) => ({ ...map, [statisticName]: value }), {});
+    // Render
+    console.log([
+        `${displayName}`,
+        `${publisherDisplayName} | ${viewutils_1.icons.download} ` +
+            `${Number(installs).toLocaleString()} installs |` +
+            ` ${(0, viewutils_1.ratingStars)(averagerating)} (${ratingcount})`,
+        '',
+        `${shortDescription}`,
+        '',
+        'Recent versions:',
+        ...(versionList.length ? (0, viewutils_1.tableView)(versionList).map(viewutils_1.indentRow) : ['no versions found']),
+        '',
+        'Categories:',
+        `  ${categories.join(', ')}`,
+        '',
+        'Tags:',
+        `  ${tags.filter(tag => !isExtensionTag.test(tag)).join(', ')}`,
+        '',
+        'More info:',
+        ...(0, viewutils_1.tableView)([
+            ['Unique identifier:', `${publisherName}.${extensionName}`],
+            ['Version:', version],
+            ['Last updated:', (0, viewutils_1.formatDateTime)(lastUpdated)],
+            ['Publisher:', publisherDisplayName],
+            ['Published at:', (0, viewutils_1.formatDate)(publishedDate)],
+        ]).map(viewutils_1.indentRow),
+        '',
+        'Statistics:',
+        ...(0, viewutils_1.tableView)(statistics.map(({ statisticName, value }) => [statisticName, Number(value).toFixed(2)])).map(viewutils_1.indentRow),
+    ]
+        .map(line => (0, viewutils_1.wordWrap)(line))
+        .join('\n'));
+}
+//# sourceMappingURL=show.js.map

package/out/store.js

@@ -0,0 +1,225 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listPublishers = exports.deletePublisher = exports.logoutPublisher = exports.loginPublisher = exports.getPublisher = exports.verifyPat = exports.KeytarStore = exports.FileStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os_1 = require("os");
+const util_1 = require("./util");
+const validation_1 = require("./validation");
+const package_1 = require("./package");
+class FileStore {
+    constructor(path, publishers) {
+        this.path = path;
+        this.publishers = publishers;
+    }
+    static async open(path = FileStore.DefaultPath) {
+        try {
+            const rawStore = await fs.promises.readFile(path, 'utf8');
+            return new FileStore(path, JSON.parse(rawStore).publishers);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                return new FileStore(path, []);
+            }
+            else if (/SyntaxError/.test(err)) {
+                throw new Error(`Error parsing file store: ${path}`);
+            }
+            throw err;
+        }
+    }
+    get size() {
+        return this.publishers.length;
+    }
+    async save() {
+        await fs.promises.writeFile(this.path, JSON.stringify({ publishers: this.publishers }), { mode: '0600' });
+    }
+    async deleteStore() {
+        try {
+            await fs.promises.unlink(this.path);
+        }
+        catch {
+            // noop
+        }
+    }
+    get(name) {
+        return this.publishers.filter(p => p.name === name)[0];
+    }
+    async add(publisher) {
+        this.publishers = [...this.publishers.filter(p => p.name !== publisher.name), publisher];
+        await this.save();
+    }
+    async delete(name) {
+        this.publishers = this.publishers.filter(p => p.name !== name);
+        await this.save();
+    }
+    [Symbol.iterator]() {
+        return this.publishers[Symbol.iterator]();
+    }
+}
+exports.FileStore = FileStore;
+FileStore.DefaultPath = path.join((0, os_1.homedir)(), '.vsce');
+class KeytarStore {
+    constructor(keytar, serviceName, publishers) {
+        this.keytar = keytar;
+        this.serviceName = serviceName;
+        this.publishers = publishers;
+    }
+    static async open(serviceName = 'vscode-vsce') {
+        const keytar = await Promise.resolve().then(() => __importStar(require('keytar')));
+        const creds = await keytar.findCredentials(serviceName);
+        return new KeytarStore(keytar, serviceName, creds.map(({ account, password }) => ({ name: account, pat: password })));
+    }
+    get size() {
+        return this.publishers.length;
+    }
+    get(name) {
+        return this.publishers.filter(p => p.name === name)[0];
+    }
+    async add(publisher) {
+        this.publishers = [...this.publishers.filter(p => p.name !== publisher.name), publisher];
+        await this.keytar.setPassword(this.serviceName, publisher.name, publisher.pat);
+    }
+    async delete(name) {
+        this.publishers = this.publishers.filter(p => p.name !== name);
+        await this.keytar.deletePassword(this.serviceName, name);
+    }
+    [Symbol.iterator]() {
+        return this.publishers[Symbol.iterator]();
+    }
+}
+exports.KeytarStore = KeytarStore;
+async function verifyPat(pat, publisherName) {
+    if (!pat) {
+        throw new Error('The Personal Access Token is mandatory.');
+    }
+    if (!publisherName) {
+        try {
+            publisherName = (await (0, package_1.readManifest)()).publisher;
+        }
+        catch (error) {
+            throw new Error(`Can not read the publisher's name. Either supply it as an argument or run vsce from the extension folder. Additional information:\n\n${error}`);
+        }
+    }
+    try {
+        // If the caller of the `getRoleAssignments` API has any of the roles
+        // (Creator, Owner, Contributor, Reader) on the publisher, we get a 200,
+        // otherwise we get a 403.
+        const api = await (0, util_1.getSecurityRolesAPI)(pat);
+        await api.getRoleAssignments('gallery.publisher', publisherName);
+    }
+    catch (error) {
+        throw new Error('The Personal Access Token verification has failed. Additional information:\n\n' + error);
+    }
+    console.log(`The Personal Access Token verification succeeded for the publisher '${publisherName}'.`);
+}
+exports.verifyPat = verifyPat;
+async function requestPAT(publisherName) {
+    console.log('https://marketplace.visualstudio.com/manage/publishers/');
+    const pat = await (0, util_1.read)(`Personal Access Token for publisher '${publisherName}':`, { silent: true, replace: '*' });
+    await verifyPat(pat, publisherName);
+    return pat;
+}
+async function openDefaultStore() {
+    if (/^file$/i.test(process.env['VSCE_STORE'] ?? '')) {
+        return await FileStore.open();
+    }
+    let keytarStore;
+    try {
+        keytarStore = await KeytarStore.open();
+    }
+    catch (err) {
+        const store = await FileStore.open();
+        util_1.log.warn(`Failed to open credential store. Falling back to storing secrets clear-text in: ${store.path}`);
+        return store;
+    }
+    const fileStore = await FileStore.open();
+    // migrate from file store
+    if (fileStore.size) {
+        for (const publisher of fileStore) {
+            await keytarStore.add(publisher);
+        }
+        await fileStore.deleteStore();
+        util_1.log.info(`Migrated ${fileStore.size} publishers to system credential manager. Deleted local store '${fileStore.path}'.`);
+    }
+    return keytarStore;
+}
+async function getPublisher(publisherName) {
+    (0, validation_1.validatePublisher)(publisherName);
+    const store = await openDefaultStore();
+    let publisher = store.get(publisherName);
+    if (publisher) {
+        return publisher;
+    }
+    const pat = await requestPAT(publisherName);
+    publisher = { name: publisherName, pat };
+    await store.add(publisher);
+    return publisher;
+}
+exports.getPublisher = getPublisher;
+async function loginPublisher(publisherName) {
+    (0, validation_1.validatePublisher)(publisherName);
+    const store = await openDefaultStore();
+    let publisher = store.get(publisherName);
+    if (publisher) {
+        console.log(`Publisher '${publisherName}' is already known`);
+        const answer = await (0, util_1.read)('Do you want to overwrite its PAT? [y/N] ');
+        if (!/^y$/i.test(answer)) {
+            throw new Error('Aborted');
+        }
+    }
+    const pat = await requestPAT(publisherName);
+    publisher = { name: publisherName, pat };
+    await store.add(publisher);
+    return publisher;
+}
+exports.loginPublisher = loginPublisher;
+async function logoutPublisher(publisherName) {
+    (0, validation_1.validatePublisher)(publisherName);
+    const store = await openDefaultStore();
+    const publisher = store.get(publisherName);
+    if (!publisher) {
+        throw new Error(`Unknown publisher '${publisherName}'`);
+    }
+    await store.delete(publisherName);
+}
+exports.logoutPublisher = logoutPublisher;
+async function deletePublisher(publisherName) {
+    const publisher = await getPublisher(publisherName);
+    const answer = await (0, util_1.read)(`This will FOREVER delete '${publisherName}'! Are you sure? [y/N] `);
+    if (!/^y$/i.test(answer)) {
+        throw new Error('Aborted');
+    }
+    const api = await (0, util_1.getGalleryAPI)(publisher.pat);
+    await api.deletePublisher(publisherName);
+    const store = await openDefaultStore();
+    await store.delete(publisherName);
+    util_1.log.done(`Deleted publisher '${publisherName}'.`);
+}
+exports.deletePublisher = deletePublisher;
+async function listPublishers() {
+    const store = await openDefaultStore();
+    for (const publisher of store) {
+        console.log(publisher.name);
+    }
+}
+exports.listPublishers = listPublishers;
+//# sourceMappingURL=store.js.map