@google/clasp 2.5.0 → 3.0.1-alpha1

package/build/src/auth/auth.js

@@ -0,0 +1,176 @@
+import { readFileSync } from 'fs';
+import os from 'os';
+import path from 'path';
+import { GoogleAuth, OAuth2Client } from 'google-auth-library';
+import { google } from 'googleapis';
+import { FileCredentialStore } from './file_credential_store.js';
+import { LocalServerAuthorizationCodeFlow } from './localhost_auth_code_flow.js';
+import { ServerlessAuthorizationCodeFlow } from './serverless_auth_code_flow.js';
+export async function initAuth(options) {
+    var _a, _b, _c;
+    const authFilePath = (_a = options.authFilePath) !== null && _a !== void 0 ? _a : path.join(os.homedir(), '.clasprc.json');
+    const credentialStore = new FileCredentialStore(authFilePath);
+    if (options.useApplicationDefaultCredentials) {
+        const credentials = await createApplicationDefaultCredentials();
+        return {
+            credentials,
+            credentialStore,
+            user: (_b = options.userKey) !== null && _b !== void 0 ? _b : 'default',
+        };
+    }
+    const credentials = await getAuthorizedOAuth2Client(credentialStore, options.userKey);
+    return {
+        credentials,
+        credentialStore,
+        user: (_c = options.userKey) !== null && _c !== void 0 ? _c : 'default',
+    };
+}
+export async function getUserInfo(credentials) {
+    const api = google.oauth2('v2');
+    const res = await api.userinfo.get({ auth: credentials });
+    if (res.status !== 200) {
+        return undefined;
+    }
+    return {
+        email: res.data.email,
+        id: res.data.id,
+    };
+}
+/**
+ * Creates an an unauthorized oauth2 client given the client secret file. If no path is provided,
+ * teh default client is returned.
+ * @param clientSecretPath
+ * @returns
+ */
+export function getUnauthorizedOuth2Client(clientSecretPath) {
+    if (clientSecretPath) {
+        return createOauthClient(clientSecretPath);
+    }
+    return createDefaultOAuthClient();
+}
+/**
+ * Create an authorized oauth2 client from saved credentials.
+ * @param userKey
+ * @returns
+ */
+export async function getAuthorizedOAuth2Client(store, userKey) {
+    if (!userKey) {
+        userKey = 'default';
+    }
+    const savedCredentials = await store.load(userKey);
+    if (!savedCredentials) {
+        return undefined;
+    }
+    const client = new GoogleAuth().fromJSON(savedCredentials);
+    client.setCredentials(savedCredentials);
+    client.on('tokens', async (tokens) => {
+        const refreshedCredentials = {
+            ...savedCredentials,
+            expiry_date: tokens.expiry_date,
+            access_token: tokens.access_token,
+            id_token: tokens.access_token,
+        };
+        await store.save(userKey, refreshedCredentials);
+    });
+    return client;
+}
+/**
+ * Requests authorization to manage Apps Script projects.
+ * @param {boolean} useLocalhost Uses a local HTTP server if true. Manual entry o.w.
+ * @param {ClaspCredentials?} creds An optional credentials object.
+ * @param {string[]} [scopes=[]] List of OAuth scopes to authorize.
+ * @param {number?} redirectPort Optional custom port for the local HTTP server during the authorization process.
+ *                               If not specified, a random available port will be used.
+ */
+export async function authorize(options) {
+    let flow;
+    if (options.noLocalServer) {
+        flow = new ServerlessAuthorizationCodeFlow(options.oauth2Client);
+    }
+    else {
+        flow = new LocalServerAuthorizationCodeFlow(options.oauth2Client);
+    }
+    const client = await flow.authorize(options.scopes);
+    await saveOauthClientCredentials(options.store, options.userKey, client);
+    return client;
+}
+async function saveOauthClientCredentials(store, userKey, oauth2Client) {
+    var _a, _b;
+    const savedCredentials = {
+        client_id: oauth2Client._clientId,
+        client_secret: oauth2Client._clientSecret,
+        type: 'authorized_user',
+        refresh_token: (_a = oauth2Client.credentials.refresh_token) !== null && _a !== void 0 ? _a : undefined,
+        access_token: (_b = oauth2Client.credentials.access_token) !== null && _b !== void 0 ? _b : undefined,
+    };
+    oauth2Client.on('tokens', async (tokens) => {
+        const refreshedCredentials = {
+            ...savedCredentials,
+            expiry_date: tokens.expiry_date,
+            access_token: tokens.access_token,
+            id_token: tokens.access_token,
+        };
+        await store.save(userKey, refreshedCredentials);
+    });
+    await store.save(userKey, savedCredentials);
+}
+/**
+ * Creates an aunthorized oauth2 client with the given credentials
+ * @param clientSecretPath
+ * @returns
+ */
+function createOauthClient(clientSecretPath) {
+    if (!clientSecretPath) {
+        throw new Error('Invalid credentials');
+    }
+    const contents = readFileSync(clientSecretPath);
+    const keyFile = JSON.parse(contents.toString());
+    const keys = keyFile.installed || keyFile.web;
+    if (!keys.redirect_uris || keys.redirect_uris.length === 0) {
+        throw new Error('Invalid redirect URL');
+    }
+    const redirectUrl = keys.redirect_uris.find((uri) => new URL(uri).hostname === 'localhost');
+    if (!redirectUrl) {
+        throw new Error('No localhost redirect URL found');
+    }
+    // create an oAuth client to authorize the API call
+    return new OAuth2Client({
+        clientId: keys.client_id,
+        clientSecret: keys.client_secret,
+        redirectUri: redirectUrl,
+    });
+}
+/**
+ * Creates an aunthorized oauth2 client using the default id & secret.
+ * @param clientSecretPath
+ * @returns
+ */
+function createDefaultOAuthClient() {
+    // Default client
+    return new OAuth2Client({
+        clientId: '1072944905499-vm2v2i5dvn0a0d2o4ca36i1vge8cvbn0.apps.googleusercontent.com',
+        clientSecret: 'v6V3fKV_zWU7iw1DrpO1rknX',
+        redirectUri: 'http://localhost',
+    });
+}
+export async function createApplicationDefaultCredentials() {
+    const defaultCreds = await new GoogleAuth({
+        scopes: [
+            'https://www.googleapis.com/auth/script.deployments', // Apps Script deployments
+            'https://www.googleapis.com/auth/script.projects', // Apps Script management
+            'https://www.googleapis.com/auth/script.webapp.deploy', // Apps Script Web Apps
+            'https://www.googleapis.com/auth/drive.metadata.readonly', // Drive metadata
+            'https://www.googleapis.com/auth/drive.file', // Create Drive files
+            'https://www.googleapis.com/auth/service.management', // Cloud Project Service Management API
+            'https://www.googleapis.com/auth/logging.read', // StackDriver logs
+            'https://www.googleapis.com/auth/userinfo.email', // User email address
+            'https://www.googleapis.com/auth/userinfo.profile',
+            'https://www.googleapis.com/auth/cloud-platform',
+        ],
+    }).getClient();
+    // Remove this check after https://github.com/googleapis/google-auth-library-nodejs/issues/1677 fixed
+    if (defaultCreds instanceof OAuth2Client) {
+        return defaultCreds;
+    }
+    return undefined;
+}

package/build/src/auth/auth_code_flow.js

@@ -0,0 +1,36 @@
+export class AuthorizationCodeFlow {
+    constructor(oauth2client) {
+        this.oauth2Client = oauth2client;
+    }
+    async authorize(scopes) {
+        const scope = Array.isArray(scopes) ? scopes.join(' ') : scopes;
+        const redirectUri = await this.getRedirectUri();
+        const authUrl = this.oauth2Client.generateAuthUrl({
+            redirect_uri: redirectUri,
+            access_type: 'offline',
+            scope: scope,
+        });
+        const code = await this.promptAndReturnCode(authUrl);
+        const tokens = await this.oauth2Client.getToken({
+            code,
+            redirect_uri: redirectUri,
+        });
+        this.oauth2Client.setCredentials(tokens.tokens);
+        return this.oauth2Client;
+    }
+    async getRedirectUri() {
+        throw new Error('Not implemented');
+    }
+    async promptAndReturnCode(_authorizationUrl) {
+        throw new Error('Not implemented');
+    }
+}
+export function parseAuthResponseUrl(url) {
+    const urlParts = new URL(url, 'http://localhost/').searchParams;
+    const code = urlParts.get('code');
+    const error = urlParts.get('error');
+    return {
+        code,
+        error,
+    };
+}

package/build/src/auth/credential_store.js

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

package/build/src/auth/file_credential_store.js

@@ -0,0 +1,82 @@
+import fs from 'fs';
+function hasLegacyLocalCredentials(store) {
+    return store.token && store.oauth2ClientSettings;
+}
+function hasLegacyGlobalCredentials(store) {
+    return !!store.access_token;
+}
+export class FileCredentialStore {
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async save(user, credentials) {
+        const store = this.readFile();
+        if (!store.tokens) {
+            store.tokens = {};
+        }
+        store.tokens[user] = credentials;
+        this.writeFile(store);
+    }
+    async delete(user) {
+        let store = this.readFile();
+        if (!store.tokens) {
+            store.tokens = {};
+        }
+        store.tokens[user] = undefined;
+        if (user === 'default') {
+            // Remove legacy keys if default user
+            store = {
+                tokens: store.tokens,
+            };
+        }
+        this.writeFile(store);
+    }
+    async deleteAll() {
+        await this.writeFile({
+            tokens: {},
+        });
+    }
+    async load(user) {
+        var _a, _b, _c;
+        const store = this.readFile();
+        const credentials = (_a = store.tokens) === null || _a === void 0 ? void 0 : _a[user];
+        if (credentials) {
+            return credentials;
+        }
+        if (user !== 'default') {
+            return null;
+        }
+        if (hasLegacyLocalCredentials(store)) {
+            // Support previous un
+            return {
+                type: 'authorized_user',
+                ...store.token,
+                client_id: (_b = store.oauth2ClientSettings) === null || _b === void 0 ? void 0 : _b.clientId,
+                client_secret: (_c = store.oauth2ClientSettings) === null || _c === void 0 ? void 0 : _c.clientSecret,
+            };
+        }
+        if (hasLegacyGlobalCredentials(store)) {
+            return {
+                type: 'authorized_user',
+                access_token: store.access_token,
+                refresh_token: store.refresh_token,
+                expiry_date: store.exprity_date,
+                token_type: store.token_type,
+                client_id: '1072944905499-vm2v2i5dvn0a0d2o4ca36i1vge8cvbn0.apps.googleusercontent.com',
+                client_secret: 'v6V3fKV_zWU7iw1DrpO1rknX',
+            };
+        }
+        return null;
+    }
+    readFile() {
+        if (fs.existsSync(this.filePath)) {
+            // TODO - use promises
+            const content = fs.readFileSync(this.filePath, { encoding: 'utf8' });
+            return JSON.parse(content);
+        }
+        return {};
+    }
+    writeFile(store) {
+        fs.writeFileSync(this.filePath, JSON.stringify(store, null, 2));
+    }
+}

package/build/src/auth/localhost_auth_code_flow.js

@@ -0,0 +1,63 @@
+import { createServer } from 'http';
+import enableDestroy from 'server-destroy';
+import { intl } from '../intl.js';
+import { AuthorizationCodeFlow, parseAuthResponseUrl } from './auth_code_flow.js';
+import open from 'open';
+export class LocalServerAuthorizationCodeFlow extends AuthorizationCodeFlow {
+    constructor(oauth2client) {
+        super(oauth2client);
+        this.port = 0;
+    }
+    async getRedirectUri() {
+        this.server = await new Promise((resolve, reject) => {
+            const s = createServer();
+            enableDestroy(s);
+            s.listen(this.port, () => resolve(s)).on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    const msg = intl.formatMessage({ id: "smVcjx", defaultMessage: [{ type: 0, value: "Error: Port " }, { type: 1, value: "port" }, { type: 0, value: " is already in use. Please specify a different port with --redirect-port" }] }, {
+                        port: this.port,
+                    });
+                    console.error(msg);
+                }
+                else {
+                    const msg = intl.formatMessage({ id: "3X2J9l", defaultMessage: [{ type: 0, value: "Error: Unable to start the server on port " }, { type: 1, value: "port" }] }, {
+                        port: this.port,
+                        errorMessage: err.message,
+                    });
+                    console.error(msg, err.message);
+                }
+                reject(err);
+            });
+        });
+        const { port } = this.server.address();
+        return `http://localhost:${port}`;
+    }
+    async promptAndReturnCode(authorizationUrl) {
+        return await new Promise((resolve, reject) => {
+            if (!this.server) {
+                reject(new Error('Server not started'));
+                return;
+            }
+            this.server.on('request', (request, response) => {
+                if (!request.url) {
+                    reject(new Error('Missing URL in request'));
+                    return;
+                }
+                const { code, error } = parseAuthResponseUrl(request.url);
+                if (code) {
+                    resolve(code);
+                }
+                else {
+                    reject(error);
+                }
+                const msg = intl.formatMessage({ id: "ZT8LeG", defaultMessage: [{ type: 0, value: "Logged in! You may close this page." }] });
+                response.end(msg);
+            });
+            void open(authorizationUrl);
+            const msg = intl.formatMessage({ id: "NbCrKh", defaultMessage: [{ type: 0, value: "`\uD83D\uDD11 Authorize clasp by visiting this url: " }, { type: 1, value: "url" }] }, {
+                url: authorizationUrl,
+            });
+            console.log(msg);
+        }).finally(() => { var _a; return (_a = this.server) === null || _a === void 0 ? void 0 : _a.destroy(); });
+    }
+}

package/build/src/auth/serverless_auth_code_flow.js

@@ -0,0 +1,32 @@
+import inquirer from 'inquirer';
+import { intl } from '../intl.js';
+import { AuthorizationCodeFlow, parseAuthResponseUrl } from './auth_code_flow.js';
+export class ServerlessAuthorizationCodeFlow extends AuthorizationCodeFlow {
+    constructor(oauth2client) {
+        super(oauth2client);
+    }
+    async getRedirectUri() {
+        return 'http://localhost:8888';
+    }
+    async promptAndReturnCode(authorizationUrl) {
+        const prompt = intl.formatMessage({ id: "Tx67iE", defaultMessage: [{ type: 0, value: "Authorize clasp by visiting the following URL on another device: " }, { type: 1, value: "url" }, { type: 0, value: " After authorization, copy the URL in the browser. Enter the URL from your browser after completing authorization" }] }, {
+            url: authorizationUrl,
+        });
+        const answer = await inquirer.prompt([
+            {
+                message: prompt,
+                name: 'url',
+                type: 'input',
+            },
+        ]);
+        const { code, error } = parseAuthResponseUrl(answer.url);
+        if (error) {
+            throw new Error(error);
+        }
+        if (!code) {
+            const msg = intl.formatMessage({ id: "XvVmSR", defaultMessage: [{ type: 0, value: "Missing code in responde URL" }] });
+            throw new Error(msg);
+        }
+        return code;
+    }
+}

package/build/src/commands/clone-script.js

@@ -0,0 +1,71 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { intl } from '../intl.js';
+import { isInteractive, withSpinner } from './utils.js';
+export const command = new Command('clone-script')
+    .alias('clone')
+    .description('Clone an existing script')
+    .arguments('[scriptId] [versionNumber]')
+    .option('--rootDir <rootDir>', 'Local root directory in which clasp will store your project files.')
+    .action(async function (scriptId, versionNumber) {
+    var _a;
+    let clasp = this.opts().clasp;
+    if (clasp.project.exists()) {
+        const msg = intl.formatMessage({ id: "kk5+4G", defaultMessage: [{ type: 0, value: "Project file already exists." }] });
+        this.error(msg);
+    }
+    const rootDir = this.opts().rootDir;
+    clasp.withContentDir(rootDir !== null && rootDir !== void 0 ? rootDir : '.');
+    if (scriptId) {
+        const match = scriptId.match(/https:\/\/script\.google\.com\/d\/([^/]+)\/.*/);
+        if (match) {
+            scriptId = match[1];
+        }
+        else {
+            scriptId = scriptId.trim();
+        }
+    }
+    else if (isInteractive()) {
+        const projects = await clasp.project.listScripts();
+        const choices = projects.results.map(file => ({
+            name: `${file.name.padEnd(20)} - https://script.google.com/d/${file.id}/edit`,
+            value: file.id,
+        }));
+        const prompt = intl.formatMessage({ id: "3aQTl3", defaultMessage: [{ type: 0, value: "Clone which script?" }] });
+        const answer = await inquirer.prompt([
+            {
+                choices: choices,
+                message: prompt,
+                name: 'scriptId',
+                pageSize: 30,
+                type: 'list',
+            },
+        ]);
+        scriptId = answer.scriptId;
+    }
+    if (!scriptId) {
+        const msg = intl.formatMessage({ id: "DJWCmP", defaultMessage: [{ type: 0, value: "No script ID." }] });
+        this.error(msg);
+    }
+    try {
+        const cloningScriptMsg = intl.formatMessage({ id: "UTMHnH", defaultMessage: [{ type: 0, value: "Cloning script..." }] });
+        const files = await withSpinner(cloningScriptMsg, async () => {
+            clasp = clasp.withScriptId(scriptId);
+            const files = await clasp.files.pull(versionNumber);
+            clasp.project.updateSettings();
+            return files;
+        });
+        files.forEach(f => console.log(`└─ ${f.localPath}`));
+        const successMessage = intl.formatMessage({ id: "Hw9Gqn", defaultMessage: [{ type: 0, value: "Warning: files in subfolder are not accounted for unless you set a .claspignore file. Cloned " }, { type: 6, value: "count", options: { "=0": { value: [{ type: 0, value: "no files." }] }, one: { value: [{ type: 0, value: "one file." }] }, other: { value: [{ type: 7 }, { type: 0, value: " files" }] } }, offset: 0, pluralType: "cardinal" }, { type: 0, value: "." }] }, {
+            count: files.length,
+        });
+        console.log(successMessage);
+    }
+    catch (error) {
+        if (((_a = error.cause) === null || _a === void 0 ? void 0 : _a.code) === 'INVALID_ARGUMENT') {
+            const msg = intl.formatMessage({ id: "jRe7cT", defaultMessage: [{ type: 0, value: "Invalid script ID." }] });
+            this.error(msg);
+        }
+        throw error;
+    }
+});

package/build/src/commands/create-deployment.js

@@ -0,0 +1,33 @@
+import { Command } from 'commander';
+import { intl } from '../intl.js';
+import { withSpinner } from './utils.js';
+export const command = new Command('create-deployment')
+    .alias('deploy')
+    .description('Deploy a project')
+    .option('-V, --versionNumber <version>', 'The project version')
+    .option('-d, --description <description>', 'The deployment description')
+    .option('-i, --deploymentId <id>', 'The deployment ID to redeploy')
+    .action(async function (options) {
+    var _a, _b, _c;
+    const clasp = this.opts().clasp;
+    const deploymentId = options.deploymentId;
+    const description = (_a = options.description) !== null && _a !== void 0 ? _a : '';
+    const versionNumber = options.versionNumber ? Number(options.versionNumber) : undefined;
+    try {
+        const spinnerMsg = intl.formatMessage({ id: "oL8t7p", defaultMessage: [{ type: 0, value: "Deploying project..." }] });
+        const deployment = await withSpinner(spinnerMsg, async () => {
+            return await clasp.project.deploy(description, deploymentId, versionNumber);
+        });
+        const successMessage = intl.formatMessage({ id: "182gSV", defaultMessage: [{ type: 0, value: "Deployed " }, { type: 1, value: "deploymentId" }, { type: 0, value: " " }, { type: 5, value: "version", options: { undefined: { value: [{ type: 0, value: "@HEAD" }] }, other: { value: [{ type: 0, value: "@" }, { type: 1, value: "version" }] } } }] }, {
+            deploymentId: deployment.deploymentId,
+            version: (_b = deployment.deploymentConfig) === null || _b === void 0 ? void 0 : _b.versionNumber,
+        });
+        console.log(successMessage);
+    }
+    catch (error) {
+        if (((_c = error.cause) === null || _c === void 0 ? void 0 : _c.code) === 'INVALID_ARGUMENT') {
+            this.error(error.cause.message);
+        }
+        throw error;
+    }
+});

package/build/src/commands/create-script.js

@@ -0,0 +1,75 @@
+import path from 'node:path';
+import { Command } from 'commander';
+import inflection from 'inflection';
+import { intl } from '../intl.js';
+import { withSpinner } from './utils.js';
+// https://developers.google.com/drive/api/v3/mime-types
+const DRIVE_FILE_MIMETYPES = {
+    docs: 'application/vnd.google-apps.document',
+    forms: 'application/vnd.google-apps.form',
+    sheets: 'application/vnd.google-apps.spreadsheet',
+    slides: 'application/vnd.google-apps.presentation',
+};
+export const command = new Command('create-script')
+    .command('create')
+    .description('Create a script')
+    .option('--type <type>', 'Creates a new Apps Script project attached to a new Document, Spreadsheet, Presentation, Form, or as a standalone script, web app, or API.', 'standalone')
+    .option('--title <title>', 'The project title.')
+    .option('--parentId <id>', 'A project parent Id.')
+    .option('--rootDir <rootDir>', 'Local root directory in which clasp will store your project files.')
+    .action(async function (options) {
+    var _a;
+    const clasp = this.opts().clasp;
+    if (clasp.project.exists()) {
+        const msg = intl.formatMessage({ id: "kk5+4G", defaultMessage: [{ type: 0, value: "Project file already exists." }] });
+        this.error(msg);
+    }
+    // Create defaults.
+    const parentId = options.parentId;
+    const name = options.title ? options.title : getDefaultProjectName(process.cwd());
+    const type = options.type ? options.type.toLowerCase() : 'standalone';
+    const rootDir = (_a = options.rootDir) !== null && _a !== void 0 ? _a : '.';
+    clasp.withContentDir(rootDir);
+    if (type && type !== 'standalone') {
+        const mimeType = DRIVE_FILE_MIMETYPES[type];
+        if (!mimeType) {
+            const msg = intl.formatMessage({ id: "d2MBtN", defaultMessage: [{ type: 0, value: "Invalid container file type" }] });
+            this.error(msg);
+        }
+        const spinnerMsg = intl.formatMessage({ id: "TMfpGK", defaultMessage: [{ type: 0, value: "Creating script..." }] });
+        const { parentId } = await withSpinner(spinnerMsg, async () => await clasp.project.createWithContainer(name, mimeType));
+        const url = `https://drive.google.com/open?id=${parentId}`;
+        const successMessage = intl.formatMessage({ id: "11VZzp", defaultMessage: [{ type: 0, value: "Created new container: [url}" }] }, {
+            url,
+        });
+        console.log(successMessage);
+    }
+    else {
+        const spinnerMsg = intl.formatMessage({ id: "TMfpGK", defaultMessage: [{ type: 0, value: "Creating script..." }] });
+        const scriptId = await withSpinner(spinnerMsg, async () => await clasp.project.createScript(name, parentId));
+        const url = `https://script.google.com/d/${scriptId}/edit`;
+        const successMessage = intl.formatMessage({ id: "NUzw0t", defaultMessage: [{ type: 0, value: "Created new script: " }, { type: 1, value: "url" }] }, {
+            url,
+        });
+        console.log(successMessage);
+    }
+    const spinnerMsg = intl.formatMessage({ id: "UTMHnH", defaultMessage: [{ type: 0, value: "Cloning script..." }] });
+    const files = await withSpinner(spinnerMsg, async () => {
+        const files = await clasp.files.pull();
+        clasp.project.updateSettings();
+        return files;
+    });
+    files.forEach(f => console.log(`└─ ${f.localPath}`));
+    const successMessage = intl.formatMessage({ id: "Hw9Gqn", defaultMessage: [{ type: 0, value: "Warning: files in subfolder are not accounted for unless you set a .claspignore file. Cloned " }, { type: 6, value: "count", options: { "=0": { value: [{ type: 0, value: "no files." }] }, one: { value: [{ type: 0, value: "one file." }] }, other: { value: [{ type: 7 }, { type: 0, value: " files" }] } }, offset: 0, pluralType: "cardinal" }, { type: 0, value: "." }] }, {
+        count: files.length,
+    });
+    console.log(successMessage);
+});
+/**
+ * Gets default project name.
+ * @return {string} default project name.
+ */
+export function getDefaultProjectName(dir) {
+    const dirName = path.basename(dir);
+    return inflection.humanize(dirName);
+}

package/build/src/commands/create-version.js

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { intl } from '../intl.js';
+import { isInteractive, withSpinner } from './utils.js';
+export const command = new Command('create-version')
+    .alias('version')
+    .arguments('[description]')
+    .description('Creates an immutable version of the script')
+    .action(async function (description) {
+    const clasp = this.opts().clasp;
+    if (!description && isInteractive()) {
+        const prompt = intl.formatMessage({ id: "6U9ksF", defaultMessage: [{ type: 0, value: "Give a description:" }] });
+        const answer = await inquirer.prompt([
+            {
+                default: '',
+                message: prompt,
+                name: 'description',
+                type: 'input',
+            },
+        ]);
+        description = answer.description;
+    }
+    const spinnerMsg = intl.formatMessage({ id: "HhBwsB", defaultMessage: [{ type: 0, value: "Creating a new version..." }] });
+    const versionNumber = await withSpinner(spinnerMsg, async () => {
+        return clasp.project.version(description);
+    });
+    const successMessage = intl.formatMessage({ id: "TVOEZz", defaultMessage: [{ type: 0, value: "Created version " }, { type: 2, value: "version", style: null }] }, {
+        version: versionNumber,
+    });
+    console.log(successMessage);
+});