bdy 1.16.19-dev → 1.16.22-dev

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.16.19-dev",
+  "version": "1.16.22-dev",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {
@@ -51,7 +51,7 @@
     "ssh2": "1.15.0",
     "tar-stream": "3.1.7",
     "terminal-kit": "3.1.1",
-    "undici": "6.21.2",
+    "undici": "6.23.0",
     "uuid": "10.0.0",
     "which": "4.0.0",
     "ws": "8.18.0",

package/distTs/src/api/client.js

@@ -8,23 +8,62 @@ const texts_1 = require("../texts");
 const logger_1 = __importDefault(require("../logger"));
 const utils_1 = require("../utils");
 const node_fs_1 = __importDefault(require("node:fs"));
+const cfg_1 = __importDefault(require("../tunnel/cfg"));
 class ApiClient {
     client;
     token;
+    refreshToken;
+    clientId;
+    clientSecret;
+    clientToken;
     baseUrl;
-    constructor(baseUrl, token) {
+    constructor(baseUrl, token, refreshToken, clientId, clientSecret, clientToken) {
         this.baseUrl = baseUrl;
         this.token = token;
+        this.refreshToken = refreshToken;
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+        this.clientToken = clientToken;
         this.client = new undici_1.Pool(baseUrl, {
             connect: {
                 rejectUnauthorized: false,
             },
         });
     }
-    async request(method, path, body, parseResponseBody = false, rawResponseBody = false, httpUrlEncoded = false) {
-        const headers = {};
-        if (this.token)
+    async tryRefreshToken() {
+        try {
+            const data = await this.request({
+                method: 'POST',
+                path: '/oauth2/token',
+                body: {
+                    refresh_token: this.refreshToken,
+                    client_id: this.clientId,
+                    client_secret: this.clientSecret,
+                    grant_type: 'refresh_token',
+                },
+                parseResponseBody: true,
+                httpUrlEncoded: true,
+                tryRefreshingToken: false,
+            });
+            if (data && data.access_token && data.refresh_token) {
+                this.token = data.access_token;
+                this.refreshToken = data.refresh_token;
+                cfg_1.default.setApiToken(this.token);
+                cfg_1.default.setApiRefreshToken(this.refreshToken);
+                return true;
+            }
+        }
+        catch {
+            // do nothing
+        }
+        return false;
+    }
+    async request({ method = 'GET', path, body = null, headers = {}, parseResponseBody = false, rawResponseBody = false, httpUrlEncoded = false, tryRefreshingToken = true, }) {
+        if (!headers)
+            headers = {};
+        if (this.token && !headers.authorization) {
             headers.authorization = `Bearer ${this.token}`;
+        }
         let bodyParsed = undefined;
         if (body) {
             if (body instanceof undici_1.FormData) {
@@ -32,11 +71,15 @@ class ApiClient {
             }
             else {
                 if (httpUrlEncoded) {
-                    headers['content-type'] = 'application/x-www-form-urlencoded; charset=utf-8';
+                    if (!headers['content-type']) {
+                        headers['content-type'] = 'application/x-www-form-urlencoded; charset=utf-8';
+                    }
                     bodyParsed = new URLSearchParams(body).toString();
                 }
                 else {
-                    headers['content-type'] = 'application/json; charset=utf-8';
+                    if (!headers['content-type']) {
+                        headers['content-type'] = 'application/json; charset=utf-8';
+                    }
                     bodyParsed = JSON.stringify(body);
                 }
             }
@@ -68,6 +111,24 @@ class ApiClient {
         }
         if (status === 401) {
             await responseBody.dump();
+            if (this.refreshToken &&
+                this.clientId &&
+                this.clientSecret &&
+                tryRefreshingToken) {
+                const success = await this.tryRefreshToken();
+                if (success) {
+                    return await this.request({
+                        method,
+                        path,
+                        body,
+                        headers,
+                        parseResponseBody,
+                        rawResponseBody,
+                        httpUrlEncoded,
+                        tryRefreshingToken: false,
+                    });
+                }
+            }
             throw new Error(texts_1.ERR_REST_API_WRONG_TOKEN);
         }
         if (status === 403) {
@@ -82,7 +143,7 @@ class ApiClient {
                 throw new Error(texts_1.ERR_REST_API_RATE_LIMIT);
             }
             if (json.errors && json.errors[0] && json.errors[0].message) {
-                throw new Error(json.errors[0].message);
+                throw new Error((0, texts_1.ERR_API_MESSAGE_REPLACER)(json.errors[0].message, path, this.baseUrl));
             }
             throw new Error(texts_1.ERR_REST_API_RATE_LIMIT);
         }
@@ -100,7 +161,7 @@ class ApiClient {
             logger_1.default.debug('API CLIENT PARSED RESPONSE:');
             logger_1.default.debug(json);
             if (json.errors && json.errors[0] && json.errors[0].message) {
-                throw new Error(json.errors[0].message);
+                throw new Error((0, texts_1.ERR_API_MESSAGE_REPLACER)(json.errors[0].message, path, this.baseUrl));
             }
             if (status === 404)
                 throw new Error(texts_1.ERR_REST_API_RESOURCE_NOT_FOUND);
@@ -133,106 +194,231 @@ class ApiClient {
             await responseBody.dump();
             return null;
         }
+        else if (status === 503) {
+            throw new Error(texts_1.ERR_REST_API_NOT_RESPONDING);
+        }
         else {
             await responseBody.dump();
             throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
         }
     }
     async getPipelineRun(workspace, project, pipelineId, executionId) {
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions/${encodeURIComponent(executionId)}`, null, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions/${encodeURIComponent(executionId)}`,
+            parseResponseBody: true,
+        });
     }
     async getInvoker() {
-        return await this.request('GET', '/user', null, true);
+        return await this.request({
+            method: 'GET',
+            path: '/user',
+            parseResponseBody: true,
+        });
     }
     async getInvokerEmails() {
-        return await this.request('GET', '/user/emails', null, true);
+        return await this.request({
+            method: 'GET',
+            path: '/user/emails',
+            parseResponseBody: true,
+        });
     }
     async postPipelineRun(workspace, project, pipelineId, body) {
-        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions`, body, true);
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/projects/${encodeURIComponent(project)}/pipelines/${encodeURIComponent(pipelineId)}/executions`,
+            body,
+            parseResponseBody: true,
+        });
     }
     // Sandbox methods
     async createSandbox(workspace, project, body) {
-        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes?project_name=${encodeURIComponent(project)}`, body, true);
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes?project_name=${encodeURIComponent(project)}`,
+            body,
+            parseResponseBody: true,
+        });
     }
     async sandboxUploadFile(workspace, sandboxId, remotePath, localPath) {
         const formData = new undici_1.FormData();
         const file = await node_fs_1.default.openAsBlob(localPath);
         formData.set('file', file);
-        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/content/upload${remotePath}`, formData, true);
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/content/upload${remotePath}`,
+            body: formData,
+            parseResponseBody: true,
+        });
     }
     async listSandboxes(workspace, project) {
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes?project_name=${encodeURIComponent(project)}`, null, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes?project_name=${encodeURIComponent(project)}`,
+            parseResponseBody: true,
+        });
     }
     async getSandbox(workspace, sandboxId) {
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}`, null, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}`,
+            parseResponseBody: true,
+        });
     }
     async deleteSandbox(workspace, sandboxId) {
-        return await this.request('DELETE', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}`, null, false);
+        return await this.request({
+            method: 'DELETE',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}`,
+            parseResponseBody: false,
+        });
     }
     async updateSandbox(workspace, sandboxId, body) {
-        return await this.request('PATCH', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}`, body, true);
+        return await this.request({
+            method: 'PATCH',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}`,
+            body,
+            parseResponseBody: true,
+        });
     }
     async startSandbox(workspace, sandboxId) {
-        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/start`, {}, true);
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/start`,
+            parseResponseBody: true,
+        });
     }
     async stopSandbox(workspace, sandboxId) {
-        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/stop`, {}, true);
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/stop`,
+            parseResponseBody: true,
+        });
     }
     async registerApp(name, redirectUrl) {
-        return await this.request('POST', '/auth/register', {
-            redirect_uris: [redirectUrl],
-            client_name: name,
-            grant_types: ['authorization_code', 'refresh_token'],
-            response_types: ['code'],
-            token_endpoint_auth_method: "client_secret_basic",
-            token_expires_in: 3600
-        }, true);
+        return await this.request({
+            method: 'POST',
+            path: '/auth/register',
+            body: {
+                redirect_uris: [redirectUrl],
+                client_name: name,
+                grant_types: ['authorization_code', 'refresh_token'],
+                response_types: ['code'],
+                token_endpoint_auth_method: 'client_secret_basic',
+                token_expires_in: 3600,
+            },
+            parseResponseBody: true,
+        });
     }
     async getApp(clientId) {
-        return await this.request('GET', `/auth/register/${encodeURIComponent(clientId)}`, null, true);
+        return await this.request({
+            method: 'GET',
+            path: `/auth/register/${encodeURIComponent(clientId)}`,
+            headers: {
+                authorization: `Bearer ${this.clientToken || ''}`,
+            },
+            parseResponseBody: true,
+        });
+    }
+    async deleteApp(clientId) {
+        return await this.request({
+            method: 'DELETE',
+            path: `/auth/register/${encodeURIComponent(clientId)}`,
+            headers: {
+                authorization: `Bearer ${this.clientToken || ''}`,
+            },
+            parseResponseBody: true,
+        });
     }
     async exchangeAppToken(code, clientId, clientSecret, redirectUrl) {
-        return await this.request('POST', '/oauth2/token', {
-            grant_type: 'authorization_code',
-            code,
-            client_id: clientId,
-            client_secret: clientSecret,
-            redirect_uri: redirectUrl
-        }, true, false, true);
+        return await this.request({
+            method: 'POST',
+            path: '/oauth2/token',
+            body: {
+                grant_type: 'authorization_code',
+                code,
+                client_id: clientId,
+                client_secret: clientSecret,
+                redirect_uri: redirectUrl,
+            },
+            parseResponseBody: true,
+            httpUrlEncoded: true,
+        });
     }
     async restartSandbox(workspace, sandboxId) {
-        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/restart`, {}, true);
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/restart`,
+            parseResponseBody: true,
+        });
     }
     async executeSandboxCommand(workspace, sandboxId, body) {
-        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands`, body, true);
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands`,
+            body,
+            parseResponseBody: true,
+        });
     }
     async getSandboxCommand(workspace, sandboxId, commandId) {
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}`, null, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}`,
+            parseResponseBody: true,
+        });
     }
     async listSandboxCommands(workspace, sandboxId) {
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands`, null, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands`,
+            parseResponseBody: true,
+        });
     }
     async streamSandboxCommandLogs(workspace, sandboxId, commandId, follow = true) {
         let q = '';
         if (follow)
             q = '?follow=true';
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}/logs${q}`, null, false, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}/logs${q}`,
+            parseResponseBody: false,
+            rawResponseBody: true,
+        });
     }
     async terminateSandboxCommand(workspace, sandboxId, commandId) {
-        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}/terminate`, {}, true);
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/commands/${encodeURIComponent(commandId)}/terminate`,
+            parseResponseBody: true,
+        });
     }
     // Snapshot methods
     async listSandboxSnapshots(workspace, sandboxId) {
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots`, null, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots`,
+            parseResponseBody: true,
+        });
     }
     async createSandboxSnapshot(workspace, sandboxId, body) {
-        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots`, body, true);
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots`,
+            body,
+            parseResponseBody: true,
+        });
     }
     async getSandboxSnapshot(workspace, sandboxId, snapshotId) {
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(snapshotId)}`, null, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(snapshotId)}`,
+            parseResponseBody: true,
+        });
     }
     async deleteSandboxSnapshot(workspace, sandboxId, snapshotId) {
-        return await this.request('DELETE', `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(snapshotId)}`, null, false);
+        return await this.request({
+            method: 'DELETE',
+            path: `/workspaces/${encodeURIComponent(workspace)}/sandboxes/${encodeURIComponent(sandboxId)}/snapshots/${encodeURIComponent(snapshotId)}`,
+        });
     }
     async sandboxWaitForSnapshot(workspace, sandboxId, snapshotId, timeout = 300) {
         const end = Date.now() + timeout * 1000;
@@ -303,16 +489,28 @@ class ApiClient {
         }
     }
     async getWorkspaces() {
-        return await this.request('GET', '/workspaces', null, true);
+        return await this.request({
+            method: 'GET',
+            path: '/workspaces',
+            parseResponseBody: true,
+        });
     }
     async getPackages(workspace, project) {
         let query = '';
         if (project)
             query += `?project_name=${encodeURIComponent(project)}`;
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/packages${query}`, null, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/packages${query}`,
+            parseResponseBody: true,
+        });
     }
     async getProjects(workspace) {
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/projects`, null, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/projects`,
+            parseResponseBody: true,
+        });
     }
     async getResourceByIdentifier(workspace, params) {
         let query = '';
@@ -323,10 +521,17 @@ class ApiClient {
                 query += '&';
             query += encodeURIComponent(key) + '=' + encodeURIComponent(params[key]);
         });
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/identifiers${query}`, null, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/identifiers${query}`,
+            parseResponseBody: true,
+        });
     }
     async getPipelineByIdentifier(workspace, project, identifier) {
-        return await this.getResourceByIdentifier(workspace, { project, pipeline: identifier });
+        return await this.getResourceByIdentifier(workspace, {
+            project,
+            pipeline: identifier,
+        });
     }
     async getPackageVersionByIdentifier(workspace, project, pkg, version) {
         const opts = {
@@ -339,27 +544,49 @@ class ApiClient {
         return await this.getResourceByIdentifier(workspace, opts);
     }
     async getPackageVersion(workspace, pkgId, versionId) {
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions/${encodeURIComponent(versionId)}`, null, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions/${encodeURIComponent(versionId)}`,
+            parseResponseBody: true,
+        });
     }
     async getPackageLatest(workspace, pkgId) {
-        const res = await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions?page=1&per_page=1`, null, true);
+        const res = await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions?page=1&per_page=1`,
+            parseResponseBody: true,
+        });
         if (res && res.versions && res.versions.length > 0) {
             return res.versions[0];
         }
         return null;
     }
     async downloadPackageVersion(workspace, pkgId, versionId) {
-        return await this.request('GET', `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions/${encodeURIComponent(versionId)}/download`, null, false, true);
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions/${encodeURIComponent(versionId)}/download`,
+            rawResponseBody: true,
+        });
     }
     async postPackageVersion(workspace, pkgId, version) {
-        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions`, {
-            version
-        }, true);
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions`,
+            body: {
+                version,
+            },
+            parseResponseBody: true,
+        });
     }
     async postPackageVersionZip(workspace, pkgId, versionId, file) {
         const form = new undici_1.FormData();
         form.append('file', file);
-        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions/${versionId}/upload`, form, true);
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/packages/${encodeURIComponent(pkgId)}/versions/${versionId}/upload`,
+            body: form,
+            parseResponseBody: true,
+        });
     }
     async postPackage(workspace, project, identifier) {
         const body = {
@@ -368,16 +595,21 @@ class ApiClient {
             type: 'FILE',
             scope: 'WORKSPACE',
             authorization: {
-                type: 'BUDDY'
-            }
+                type: 'BUDDY',
+            },
         };
         if (project) {
             body.project = {
-                name: project
+                name: project,
             };
             body.scope = 'PROJECT';
         }
-        return await this.request('POST', `/workspaces/${encodeURIComponent(workspace)}/packages`, body, true);
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/packages`,
+            body,
+            parseResponseBody: true,
+        });
     }
 }
 exports.default = ApiClient;

package/distTs/src/command/login.js

@@ -62,7 +62,10 @@ async function oauthServer(api, clientId, clientSecret) {
                 const response = await client.exchangeAppToken(urlCode, clientId, clientSecret, OAUTH_CLIENT_APP_REDIRECT_URL);
                 res.end(texts_1.ERR_LOGIN_HTTP_SUCCESS);
                 s.close();
-                resolve(response.access_token);
+                resolve({
+                    token: response.access_token,
+                    refreshToken: response.refresh_token,
+                });
             }
             catch {
                 res.end(texts_1.ERR_LOGIN_HTTP_FAILED);
@@ -84,11 +87,14 @@ async function getOrCreateApp(api) {
     const client = new client_1.default(new URL(`https://${api}`));
     let clientId = cfg_1.default.getApiClientId();
     let clientSecret = cfg_1.default.getApiClientSecret();
-    if (clientId && clientSecret) {
+    let clientToken = cfg_1.default.getApiClientToken();
+    if (clientId && clientSecret && clientToken) {
         let clear = false;
         try {
             const app = await client.getApp(clientId);
-            if (!app || !app.redirect_uris || !app.redirect_uris.includes(OAUTH_CLIENT_APP_REDIRECT_URL)) {
+            if (!app ||
+                !app.redirect_uris ||
+                !app.redirect_uris.includes(OAUTH_CLIENT_APP_REDIRECT_URL)) {
                 clear = true;
             }
         }
@@ -98,25 +104,31 @@ async function getOrCreateApp(api) {
         if (clear) {
             clientId = null;
             clientSecret = null;
+            clientToken = null;
         }
     }
-    if (!clientId || !clientSecret) {
-        const app = await client.registerApp('bdy cli app', OAUTH_CLIENT_APP_REDIRECT_URL);
+    if (!clientId || !clientSecret || !clientToken) {
+        const app = await client.registerApp('Buddy CLI', OAUTH_CLIENT_APP_REDIRECT_URL);
         clientId = app.client_id;
         clientSecret = app.client_secret;
-        cfg_1.default.setApiClient(clientId, clientSecret);
+        clientToken = app.registration_access_token;
+        cfg_1.default.setApiClient(clientId, clientSecret, clientToken);
     }
     return {
         clientId,
         clientSecret,
+        clientToken,
     };
 }
 async function authorizeOAuth(api) {
-    const { clientId, clientSecret } = await getOrCreateApp(api);
-    return await oauthServer(api, clientId, clientSecret);
+    const { clientId, clientSecret, clientToken } = await getOrCreateApp(api);
+    const { token, refreshToken } = await oauthServer(api, clientId, clientSecret);
+    return { token, refreshToken, clientId, clientSecret, clientToken };
 }
-async function authorizeToken(api, token, workspace, project) {
-    const client = new client_1.default(new URL(`https://${api}`), token);
+async function authorizeToken(api, token, refreshToken, clientId, clientSecret, clientToken, workspace, project) {
+    cfg_1.default.setApiToken(token);
+    cfg_1.default.setApiRefreshToken(refreshToken);
+    const client = new client_1.default(new URL(`https://${api}`), token, refreshToken, clientId, clientSecret, clientToken);
     const w = await client.getWorkspaces();
     if (!w.workspaces?.length) {
         output_1.default.exitError(texts_1.ERR_LOGIN_NO_WORKSPACES);
@@ -130,7 +142,6 @@ async function authorizeToken(api, token, workspace, project) {
     else {
         workspace = await output_1.default.selectWorkspace(w.workspaces);
     }
-    cfg_1.default.setApiToken(token);
     cfg_1.default.setWorkspace(workspace);
     const p = await client.getProjects(workspace);
     if (project) {
@@ -185,11 +196,11 @@ commandLogin.action(async (options) => {
     cfg_1.default.setBaseUrl(api);
     if (!token) {
         output_1.default.normal(texts_1.TXT_LOGIN_OAUTH);
-        const token = await authorizeOAuth(api);
-        await authorizeToken(api, token, workspace, project);
+        const { token, refreshToken, clientId, clientSecret, clientToken } = await authorizeOAuth(api);
+        await authorizeToken(api, token, refreshToken, clientId, clientSecret, clientToken, workspace, project);
     }
     else {
-        await authorizeToken(api, token, workspace, project);
+        await authorizeToken(api, token, '', '', '', '', workspace, project);
     }
 });
 exports.default = commandLogin;

package/distTs/src/command/logout.js

@@ -7,8 +7,26 @@ const cfg_1 = __importDefault(require("../tunnel/cfg"));
 const output_1 = __importDefault(require("../output"));
 const texts_1 = require("../texts");
 const utils_1 = require("../utils");
+const client_1 = __importDefault(require("../api/client"));
+const input_1 = __importDefault(require("../input"));
 const commandLogout = (0, utils_1.newCommand)('logout', texts_1.DESC_COMMAND_LOGOUT);
+const tryRemovingApp = async () => {
+    try {
+        const token = cfg_1.default.getApiToken();
+        const refreshToken = cfg_1.default.getApiRefreshApiToken();
+        const clientId = cfg_1.default.getApiClientId();
+        const clientSecret = cfg_1.default.getApiClientSecret();
+        const clientToken = cfg_1.default.getApiClientToken();
+        const baseUrl = input_1.default.restApiBaseUrl();
+        const client = new client_1.default(baseUrl, token, refreshToken, clientId, clientSecret, clientToken);
+        await client.deleteApp(clientId);
+    }
+    catch {
+        // do nothing
+    }
+};
 commandLogout.action(async () => {
+    await tryRemovingApp();
     cfg_1.default.clearLogin();
     output_1.default.exitSuccess(texts_1.TXT_LOGOUT_SUCCESS);
 });