bdy 1.23.11-dev → 1.23.13-dev-target-commands

package/distTs/detect-rules.json

@@ -0,0 +1,351 @@
+{
+  "BUILD": {
+    "files": ["package.json", "requirements.txt", "pyproject.toml", "go.mod", "Gemfile", "pom.xml", "build.gradle", "build.gradle.kts", "Cargo.toml", "composer.json", "pubspec.yaml", "Makefile", "CMakeLists.txt"],
+    "packages": ["eslint", "oxlint", "@oxlint/cli", "@biomejs/biome", "prettier", "stylelint", "xo", "standard", "typescript"]
+  },
+  "DOCKERFILE": {
+    "files": ["Dockerfile", "Containerfile", "compose.yaml", "compose.yml", "docker-compose.yml", "docker-compose.yaml"]
+  },
+  "DOCKER_PUSH": {
+    "files": ["Dockerfile", "Containerfile"]
+  },
+  "RUN_DOCKER_CONTAINER": {
+    "files": ["Dockerfile", "Containerfile", "compose.yaml", "compose.yml", "docker-compose.yml"]
+  },
+  "DOCKERFILE_LINTER": {
+    "files": ["Dockerfile", "Containerfile"]
+  },
+  "DOCKER": {
+    "files": ["Dockerfile", "Containerfile", "compose.yaml", "compose.yml", "docker-compose.yml"]
+  },
+  "DOCKER_BUILD_MULTI_ARCH": {
+    "files": ["Dockerfile", "Containerfile"]
+  },
+  "NATIVE_BUILD_DOCKER_CLI": {
+    "files": ["Dockerfile", "Containerfile"]
+  },
+  "PROMOTE_IMAGE": {
+    "files": ["Dockerfile", "Containerfile"]
+  },
+  "KUBERNETES_APPLY": {
+    "files": ["k8s/", "kubernetes/", "kustomization.yaml", "kustomization.yml", "Kustomization"],
+    "packages": ["@aws-sdk/client-eks", "@google-cloud/container", "@azure/arm-containerservice"]
+  },
+  "KUBERNETES_SET_IMAGE": {
+    "files": ["k8s/", "kubernetes/"]
+  },
+  "KUBERNETES_RUN_POD": {
+    "files": ["k8s/", "kubernetes/"]
+  },
+  "KUBERNETES_RUN_JOB": {
+    "files": ["k8s/", "kubernetes/"]
+  },
+  "KUBERNETES_CLI": {
+    "files": ["k8s/", "kubernetes/", "kustomization.yaml", "kustomization.yml", "Kustomization"],
+    "packages": ["@kubernetes/client-node", "@aws-sdk/client-eks", "@google-cloud/container", "@azure/arm-containerservice"]
+  },
+  "HELM": {
+    "files": ["Chart.yaml", "helm/", "charts/"]
+  },
+  "WAIT_FOR_APPLY": {
+    "files": ["k8s/", "kubernetes/"]
+  },
+  "AMAZON_S3": {
+    "packages": ["aws-sdk", "@aws-sdk/client-s3"]
+  },
+  "AWS_CLI": {
+    "files": ["buildspec.yml"],
+    "packages": ["aws-sdk", "@aws-sdk/*"]
+  },
+  "AWS_CLI_2": {
+    "files": ["buildspec.yml"],
+    "packages": ["aws-sdk", "@aws-sdk/*"]
+  },
+  "AWS_LAMBDA_DEPLOY": {
+    "files": ["serverless.yml", "serverless.yaml", "samconfig.toml", "sam-template.yaml"],
+    "packages": ["aws-sdk", "@aws-sdk/client-lambda"]
+  },
+  "LAMBDA": {
+    "files": ["serverless.yml", "samconfig.toml"],
+    "packages": ["@aws-sdk/client-lambda"]
+  },
+  "AWS_ECS": {
+    "files": ["ecs-task-definition.json", "task-definition.json"],
+    "packages": ["@aws-sdk/client-ecs"]
+  },
+  "CODE_DEPLOY": {
+    "files": ["appspec.yml", "appspec.yaml"]
+  },
+  "ELASTIC_BEANSTALK": {
+    "files": [".elasticbeanstalk/"]
+  },
+  "MONITOR": {
+    "files": [".elasticbeanstalk/"]
+  },
+  "AWS_CLOUD_FORMATION": {
+    "files": ["cloudformation/"]
+  },
+  "CLOUD_FRONT": {
+    "packages": ["aws-sdk", "@aws-sdk/client-cloudfront"]
+  },
+  "CODE_PIPELINE": {
+    "files": ["buildspec.yml"]
+  },
+  "AWS_APP_RUNNER_DEPLOY": {
+    "packages": ["@aws-sdk/client-apprunner"]
+  },
+  "AWS_APP_RUNNER_MONITOR": {
+    "packages": ["@aws-sdk/client-apprunner"]
+  },
+  "AWS_CDK_CLI": {
+    "files": ["cdk.json"],
+    "packages": ["aws-cdk-lib", "aws-cdk"]
+  },
+  "DOWNLOAD_S3": {
+    "packages": ["aws-sdk", "@aws-sdk/client-s3"]
+  },
+  "GOOGLE_CLOUD_STORAGE": {
+    "packages": ["@google-cloud/storage"]
+  },
+  "GOOGLE_CLOUD_CLI": {
+    "packages": ["@google-cloud/*"]
+  },
+  "GOOGLE_APP_DEPLOY": {
+    "files": ["app.yaml"]
+  },
+  "GOOGLE_FUNCTION_DEPLOY": {
+    "files": ["firebase.json"],
+    "packages": ["@google-cloud/functions-framework"]
+  },
+  "GOOGLE_FUNCTION_INVOKE": {
+    "packages": ["@google-cloud/functions-framework"]
+  },
+  "GOOGLE_CLOUD_RUN_DEPLOY": {
+    "files": ["Dockerfile", "Containerfile"]
+  },
+  "GOOGLE_CDN_INVALIDATE": {
+    "packages": ["@google-cloud/compute"]
+  },
+  "FIREBASE": {
+    "files": ["firebase.json", ".firebaserc"],
+    "packages": ["firebase", "firebase-admin"]
+  },
+  "DOWNLOAD_GCS": {
+    "packages": ["@google-cloud/storage"]
+  },
+  "AZURE": {
+    "files": ["azure-pipelines.yml"]
+  },
+  "AZURE_CLI": {
+    "files": ["azure-pipelines.yml"],
+    "packages": ["@azure/*"]
+  },
+  "AZURE_STORAGE": {
+    "packages": ["@azure/storage-blob"]
+  },
+  "HEROKU": {
+    "files": ["Procfile"]
+  },
+  "HEROKU_CLI": {
+    "files": ["Procfile"]
+  },
+  "NETLIFY": {
+    "files": ["netlify.toml"]
+  },
+  "TERRAFORM": {
+    "files": ["*.tf", "*.tofu", "terraform/", ".terraform/"]
+  },
+  "ANDROID_SIGN": {
+    "files": ["android/", "app/src/main/AndroidManifest.xml"]
+  },
+  "ANDROID_SIGN_BUNDLE": {
+    "files": ["android/", "app/src/main/AndroidManifest.xml"]
+  },
+  "ANDROID_PUBLISH_APK": {
+    "files": ["android/", "app/src/main/AndroidManifest.xml"]
+  },
+  "ANDROID_PUBLISH_APP_BUNDLE": {
+    "files": ["android/", "app/src/main/AndroidManifest.xml"]
+  },
+  "FASTLANE_ANDROID": {
+    "files": ["fastlane/", "android/"]
+  },
+  "NATIVE_BUILD_MAC": {
+    "files": ["*.xcodeproj", "*.xcworkspace"]
+  },
+  "NATIVE_BUILD_MAC_VM": {
+    "files": ["*.xcodeproj", "*.xcworkspace"]
+  },
+  "NATIVE_BUILD_MAC_SIGN": {
+    "files": ["*.xcodeproj", "*.xcworkspace"]
+  },
+  "NATIVE_BUILD_MAC_DEPLOY": {
+    "files": ["*.xcodeproj", "*.xcworkspace"]
+  },
+  "NATIVE_BUILD_MAC_REACT": {
+    "files": ["ios/"],
+    "packages": ["react-native"]
+  },
+  "NATIVE_BUILD_MAC_CORDOVA": {
+    "packages": ["cordova"]
+  },
+  "NATIVE_BUILD_MAC_FASTLANE": {
+    "files": ["fastlane/Fastfile"]
+  },
+  "NATIVE_BUILD_MAC_FLUTTER": {
+    "files": ["pubspec.yaml", "ios/"]
+  },
+  "PLAYWRIGHT": {
+    "files": ["playwright.config.*"],
+    "packages": ["@playwright/test", "playwright"]
+  },
+  "CYPRESS": {
+    "files": ["cypress.config.*", "cypress/"],
+    "packages": ["cypress"]
+  },
+  "STORYBOOK": {
+    "files": [".storybook/"],
+    "packages": ["storybook", "@storybook/react"]
+  },
+  "LIGHTHOUSE": {
+    "packages": ["lighthouse"]
+  },
+  "JMETER_CLI": {
+    "files": ["*.jmx"]
+  },
+  "SNYK_CLI": {
+    "files": [".snyk"],
+    "packages": ["snyk"]
+  },
+  "STACK_HAWK_CLI": {
+    "files": ["stackhawk.yml"]
+  },
+  "BLACKFIRE_PHP": {
+    "packages": ["blackfire/php-sdk"]
+  },
+  "BLACKFIRE_PYTHON": {
+    "packages": ["blackfire"]
+  },
+  "BLACKFIRE_GO": {
+    "packages": ["github.com/blackfireio/go-blackfire"]
+  },
+  "SENTRY": {
+    "packages": ["@sentry/node", "@sentry/browser", "@sentry/react"]
+  },
+  "SENTRY_ENTERPRISE": {
+    "packages": ["@sentry/node", "@sentry/browser"]
+  },
+  "NEW_RELIC": {
+    "packages": ["newrelic"]
+  },
+  "NEW_RELIC_CLI": {
+    "packages": ["newrelic"]
+  },
+  "DATADOG": {
+    "packages": ["dd-trace", "datadog-metrics"]
+  },
+  "DATADOG_STATUS_CHECK": {
+    "packages": ["dd-trace"]
+  },
+  "ROLLBAR": {
+    "packages": ["rollbar"]
+  },
+  "HONEYBADGER": {
+    "packages": ["@honeybadger-io/js"]
+  },
+  "BUGSNAG": {
+    "packages": ["@bugsnag/js", "@bugsnag/node"]
+  },
+  "RAYGUN": {
+    "packages": ["raygun"]
+  },
+  "LOGGLY": {
+    "packages": ["node-loggly-bulk", "winston-loggly-bulk"]
+  },
+  "DO_SPACES": {
+    "packages": ["aws-sdk", "@aws-sdk/client-s3"]
+  },
+  "GIT_HUB_RELEASE": {
+    "files": [".github/workflows/"]
+  },
+  "GIT_HUB_CLI": {
+    "files": [".github/workflows/"]
+  },
+  "GIT_LAB_CLI": {
+    "files": [".gitlab-ci.yml"]
+  },
+  "SHOPIFY": {
+    "files": ["shopify.app.toml"],
+    "packages": ["@shopify/shopify-api"]
+  },
+  "SHOPIFY_CLI": {
+    "files": ["shopify.app.toml"],
+    "packages": ["@shopify/cli"]
+  },
+  "SHOPIFY_THEMEKIT_CLI": {
+    "files": ["shopify.app.toml"]
+  },
+  "WP_CLI": {
+    "files": ["wp-config.php", "wp-content/"]
+  },
+  "CONTENTFUL_CLI": {
+    "packages": ["contentful", "contentful-management"]
+  },
+  "MYSQL_CLI": {
+    "packages": ["mysql", "mysql2", "sequelize", "typeorm", "prisma", "drizzle-orm"]
+  },
+  "CLOUDFLARE": {
+    "files": ["wrangler.toml", "wrangler.json", "wrangler.jsonc"],
+    "packages": ["wrangler"]
+  },
+  "NATIVE_BUILD_WINDOWS": {
+    "files": ["*.sln", "*.slnx", "*.csproj"]
+  },
+  "GIT_CRYPT_UNLOCK": {
+    "files": [".git-crypt/"]
+  },
+  "GIT_CRYPT_LOCK": {
+    "files": [".git-crypt/"]
+  },
+  "JIRA_BUILD": {
+    "files": [".jira/"]
+  },
+  "JIRA_DEPLOYMENT": {
+    "files": [".jira/"]
+  },
+  "NPM_PUBLISH": {
+    "files": ["package.json"]
+  },
+  "DOCTL": {
+    "files": [".do/"],
+    "packages": ["digitalocean", "do-wrapper"]
+  },
+  "DIGITAL_OCEAN_CDN": {
+    "files": [".do/"],
+    "packages": ["digitalocean", "do-wrapper"]
+  },
+  "SLACK": {
+    "packages": ["@slack/web-api", "@slack/bolt", "@slack/webhook"]
+  },
+  "DISCORD2": {
+    "packages": ["discord.js", "discord-webhook-node"]
+  },
+  "MICROSOFT_TEAMS": {
+    "packages": ["botbuilder", "@microsoft/teams-js"]
+  },
+  "TELEGRAM": {
+    "packages": ["telegraf", "node-telegram-bot-api", "grammy"]
+  },
+  "EMAIL": {
+    "packages": ["nodemailer", "@sendgrid/mail", "postmark", "mailgun-js"]
+  },
+  "POWERSHELL": {
+    "files": ["*.ps1", "*.psm1"]
+  },
+  "GHOST_INSPECTOR_CLI": {
+    "packages": ["ghost-inspector"]
+  },
+  "BACKBLAZE_B2": {
+    "packages": ["backblaze-b2"]
+  }
+}

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.23.11-dev",
+  "version": "1.23.13-dev-target-commands",
   "type": "commonjs",
   "license": "MIT",
   "homepage": "https://buddy.works/docs/cli",
@@ -27,6 +27,8 @@
     "e2e:tunnel": "vitest run --config e2e/vitest.config.ts e2e/modules/tunnel/",
     "e2e:agent": "vitest run --config e2e/vitest.config.ts e2e/modules/agent/",
     "e2e:distro": "vitest run --config e2e/vitest.config.ts e2e/modules/distro/",
+    "e2e:target": "vitest run --config e2e/vitest.config.ts e2e/modules/target/",
+    "e2e:environment": "vitest run --config e2e/vitest.config.ts e2e/modules/environment/",
     "unit": "vitest run --config vitest.config.ts"
   },
   "files": [

package/distTs/src/api/client.js

@@ -16,6 +16,25 @@ const cfg_1 = __importDefault(require("../tunnel/cfg"));
  * echo back the escaped form - callers comparing a response against the names
  * they passed in must apply the same mapping.
  */
+const RETRIABLE_NETWORK_ERROR = /ECONNREFUSED|ECONNRESET|ETIMEDOUT/;
+// undici headers can be string | string[]; callers want the first value.
+const headerValue = (h) => Array.isArray(h) ? h[0] : h;
+// How long to wait before retrying a transient status on an idempotent
+// request, or null when a retry makes no sense (non-retriable status, or a
+// rate limit window that resets too far in the future to wait for).
+const retryDelay = (status, attempt, rateLimitReset) => {
+    if (status === 429) {
+        if (!rateLimitReset)
+            return null;
+        const ms = parseInt(rateLimitReset, 10) * 1000 - Date.now();
+        if (ms <= 0)
+            return 1000;
+        return ms > 15000 ? null : ms + 500;
+    }
+    return [502, 503, 504].includes(status) ? attempt * 1000 : null;
+};
+const RATE_LIMIT_WARN_THRESHOLD = 25;
+let rateLimitWarned = false;
 const formDataFileName = (name) => name.replace(/["\r\n]/g, (c) => ({ '"': '%22', '\r': '%0D', '\n': '%0A' })[c]);
 exports.formDataFileName = formDataFileName;
 class ApiClient {
@@ -112,20 +131,41 @@ class ApiClient {
         logger_1.default.debug(headers);
         logger_1.default.debug('BODY');
         logger_1.default.debug(bodyParsed);
-        try {
-            response = await this.client.request(opts);
-            rateLimitReset = response.headers['x-rate-limit-reset'];
+        // Transient failures (rate limit with a nearby reset, 5xx, connection
+        // resets) are retried with a backoff, but only for idempotent requests -
+        // retrying a POST could duplicate the operation.
+        const maxAttempts = method === 'GET' ? 3 : 1;
+        for (let attempt = 1;; attempt += 1) {
+            try {
+                response = await this.client.request(opts);
+            }
+            catch (err) {
+                logger_1.default.debug('API CLIENT RESPONSE ERROR');
+                logger_1.default.debug(err);
+                const retriable = RETRIABLE_NETWORK_ERROR.test(err.message);
+                if (retriable && attempt < maxAttempts) {
+                    await (0, utils_1.sleep)(attempt * 1000);
+                    continue;
+                }
+                throw new Error(retriable ? texts_1.ERR_REST_API_CONNECT_ERROR : texts_1.ERR_REST_API_GENERAL_ERROR, { cause: err });
+            }
+            rateLimitReset = headerValue(response.headers['x-rate-limit-reset']);
             status = response.statusCode;
             responseBody = response.body;
             logger_1.default.debug(`API CLIENT RESPONSE STATUS: ${status}`);
+            const delay = attempt < maxAttempts
+                ? retryDelay(status, attempt, rateLimitReset)
+                : null;
+            if (delay === null)
+                break;
+            await responseBody.dump();
+            logger_1.default.debug(`API CLIENT RETRY IN ${delay}ms`);
+            await (0, utils_1.sleep)(delay);
         }
-        catch (err) {
-            logger_1.default.debug('API CLIENT RESPONSE ERROR');
-            logger_1.default.debug(err);
-            if (/ECONNREFUSED|ECONNRESET|ETIMEDOUT/.test(err.message)) {
-                throw new Error(texts_1.ERR_REST_API_CONNECT_ERROR, { cause: err });
-            }
-            throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR, { cause: err });
+        this.warnRateLimitLow(headerValue(response.headers['x-rate-limit-remaining']), rateLimitReset);
+        if (status === 429) {
+            await responseBody.dump();
+            throw new Error((0, texts_1.ERR_REST_API_RATE_LIMIT)(rateLimitReset));
         }
         if (status === 401) {
             await responseBody.dump();
@@ -185,7 +225,7 @@ class ApiClient {
             if (status === 404)
                 throw new Error(texts_1.ERR_REST_API_RESOURCE_NOT_FOUND);
             else
-                throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
+                throw new Error((0, texts_1.ERR_REST_API_HTTP_ERROR)(status));
         }
         if ([200, 201].includes(status)) {
             if (parseResponseBody) {
@@ -221,9 +261,23 @@ class ApiClient {
         }
         else {
             await responseBody.dump();
-            throw new Error(texts_1.ERR_REST_API_GENERAL_ERROR);
+            throw new Error((0, texts_1.ERR_REST_API_HTTP_ERROR)(status));
         }
     }
+    // Set by the CLI bootstrap (Input.restApiTokenClient); the transport layer
+    // only detects the condition and leaves rendering to the caller, so
+    // non-interactive consumers (MCP proxy) stay silent.
+    static onRateLimitLow;
+    // One-time notification when the rate limit window is nearly exhausted.
+    warnRateLimitLow(remaining, reset) {
+        if (rateLimitWarned || !remaining || !ApiClient.onRateLimitLow)
+            return;
+        const left = parseInt(remaining, 10);
+        if (Number.isNaN(left) || left > RATE_LIMIT_WARN_THRESHOLD)
+            return;
+        rateLimitWarned = true;
+        ApiClient.onRateLimitLow(remaining, reset);
+    }
     async getPipelineRunActionLogs(workspace, project, pipelineId, executionId, actionExecutionId, offset, limit) {
         const query = {
             offset: String(offset),
@@ -563,6 +617,162 @@ class ApiClient {
             q.project = project;
         return await this.getResourceByIdentifier(workspace, q);
     }
+    // Target methods
+    targetScopeQuery(scope) {
+        const query = {};
+        if (scope.project)
+            query.project_name = scope.project;
+        if (scope.pipelineId)
+            query.pipeline_id = scope.pipelineId.toString();
+        if (scope.environmentId)
+            query.environment_id = scope.environmentId;
+        return query;
+    }
+    async getTargets(workspace, filters = {}) {
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets`,
+            query: this.targetScopeQuery(filters),
+            parseResponseBody: true,
+        });
+    }
+    async getTarget(workspace, targetId) {
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}`,
+            parseResponseBody: true,
+        });
+    }
+    async createTargetByYaml(workspace, scope, body) {
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/yaml`,
+            query: this.targetScopeQuery(scope),
+            body,
+            parseResponseBody: true,
+        });
+    }
+    async updateTargetByYaml(workspace, targetId, body) {
+        return await this.request({
+            method: 'PATCH',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}/yaml`,
+            body,
+            parseResponseBody: true,
+        });
+    }
+    async deleteTarget(workspace, targetId) {
+        return await this.request({
+            method: 'DELETE',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}`,
+            parseResponseBody: false,
+        });
+    }
+    async executeTargetCommand(workspace, targetId, body) {
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}/execs`,
+            body,
+            parseResponseBody: true,
+        });
+    }
+    async getTargetExecs(workspace, targetId, limit) {
+        const query = {};
+        if (limit)
+            query.limit = limit.toString();
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}/execs`,
+            query,
+            parseResponseBody: true,
+        });
+    }
+    async getTargetExec(workspace, execId, wait) {
+        const query = {};
+        if (wait)
+            query.wait = wait.toString();
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/execs/${encodeURIComponent(execId)}`,
+            query,
+            parseResponseBody: true,
+        });
+    }
+    async cancelTargetExec(workspace, execId) {
+        return await this.request({
+            method: 'DELETE',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/execs/${encodeURIComponent(execId)}`,
+            parseResponseBody: false,
+        });
+    }
+    async getTargetExecLog(workspace, execId, offset, limit) {
+        const query = {};
+        if (offset)
+            query.offset = offset.toString();
+        if (limit)
+            query.limit = limit.toString();
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/execs/${encodeURIComponent(execId)}/log`,
+            query,
+            parseResponseBody: true,
+        });
+    }
+    async getTargetByIdentifier(workspace, identifier, line = {}) {
+        return await this.getResourceByIdentifier(workspace, {
+            target: identifier,
+            ...line,
+        });
+    }
+    // Environment methods
+    async getEnvironments(workspace, project) {
+        const query = {};
+        if (project)
+            query.project_name = project;
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/environments`,
+            query,
+            parseResponseBody: true,
+        });
+    }
+    async getEnvironment(workspace, environmentId) {
+        return await this.request({
+            method: 'GET',
+            path: `/workspaces/${encodeURIComponent(workspace)}/environments/${encodeURIComponent(environmentId)}`,
+            parseResponseBody: true,
+        });
+    }
+    async createEnvironment(workspace, body) {
+        return await this.request({
+            method: 'POST',
+            path: `/workspaces/${encodeURIComponent(workspace)}/environments`,
+            body,
+            parseResponseBody: true,
+        });
+    }
+    async updateEnvironment(workspace, environmentId, body) {
+        return await this.request({
+            method: 'PATCH',
+            path: `/workspaces/${encodeURIComponent(workspace)}/environments/${encodeURIComponent(environmentId)}`,
+            body,
+            parseResponseBody: true,
+        });
+    }
+    async deleteEnvironment(workspace, environmentId) {
+        return await this.request({
+            method: 'DELETE',
+            path: `/workspaces/${encodeURIComponent(workspace)}/environments/${encodeURIComponent(environmentId)}`,
+            parseResponseBody: false,
+        });
+    }
+    async getEnvironmentByIdentifier(workspace, identifier, project) {
+        const q = {
+            environment: identifier,
+        };
+        if (project)
+            q.project = project;
+        return await this.getResourceByIdentifier(workspace, q);
+    }
     // Sandbox methods
     async createSandbox(workspace, project, body) {
         return await this.request({

package/distTs/src/cliIndex.js

@@ -24,6 +24,8 @@ const artifact_1 = __importDefault(require("./command/artifact"));
 const api_1 = __importDefault(require("./command/api"));
 const domain_1 = __importDefault(require("./command/domain"));
 const distro_1 = __importDefault(require("./command/distro"));
+const target_1 = __importDefault(require("./command/target"));
+const environment_1 = __importDefault(require("./command/environment"));
 const register_1 = __importDefault(require("./command/register"));
 const mcp_1 = __importDefault(require("./command/mcp"));
 function cliIndex() {
@@ -47,6 +49,8 @@ function cliIndex() {
     program.addCommand(sandbox_1.default);
     program.addCommand(domain_1.default);
     program.addCommand(distro_1.default);
+    program.addCommand(target_1.default);
+    program.addCommand(environment_1.default);
     program.addCommand(login_1.default);
     program.addCommand(register_1.default);
     program.addCommand(whoami_1.default);

package/distTs/src/command/artifact/list.js

@@ -18,14 +18,12 @@ commandArtifactList.action(async (options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
     const project = input_1.default.restApiProject(options.project, true);
     const scope = input_1.default.scope(project, options.scope);
+    input_1.default.projectScopeNote(options, project, scope, 'artifacts');
     const client = input_1.default.restApiTokenClient();
     const response = await client.getArtifacts(workspace, scope === distro_1.SCOPE.PROJECT ? project : null);
     const artifacts = response.artifacts || [];
     if (options.format === 'json') {
-        const filtered = scope === distro_1.SCOPE.PROJECT
-            ? artifacts.filter((a) => a.scope !== distro_1.SCOPE.WORKSPACE)
-            : artifacts;
-        output_1.default.json(filtered);
+        output_1.default.json(artifacts);
     }
     else {
         if (artifacts.length === 0) {
@@ -33,8 +31,6 @@ commandArtifactList.action(async (options) => {
         }
         const data = [['NAME', 'IDENTIFIER', 'TYPE', 'URL']];
         for (const artifact of artifacts) {
-            if (scope === distro_1.SCOPE.PROJECT && artifact.scope === distro_1.SCOPE.WORKSPACE)
-                continue;
             data.push([
                 artifact.name,
                 artifact.identifier,