bdy 1.25.21-dev → 1.25.22-master

package/distTs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.25.21-dev",
+  "version": "1.25.22-master",
   "type": "commonjs",
   "license": "MIT",
   "homepage": "https://buddy.works/docs/cli",

package/distTs/src/api/client.js

@@ -704,25 +704,25 @@ class ApiClient {
             parseResponseBody: true,
         });
     }
-    async getTargetExec(workspace, execId, wait) {
+    async getTargetExec(workspace, targetId, execId, wait) {
         const query = {};
         if (wait)
             query.wait = wait.toString();
         return await this.request({
             method: 'GET',
-            path: `/workspaces/${encodeURIComponent(workspace)}/targets/execs/${encodeURIComponent(execId)}`,
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}/execs/${encodeURIComponent(execId)}`,
             query,
             parseResponseBody: true,
         });
     }
-    async cancelTargetExec(workspace, execId) {
+    async cancelTargetExec(workspace, targetId, execId) {
         return await this.request({
             method: 'DELETE',
-            path: `/workspaces/${encodeURIComponent(workspace)}/targets/execs/${encodeURIComponent(execId)}`,
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}/execs/${encodeURIComponent(execId)}`,
             parseResponseBody: false,
         });
     }
-    async getTargetExecLog(workspace, execId, offset, limit) {
+    async getTargetExecLog(workspace, targetId, execId, offset, limit) {
         const query = {};
         if (offset)
             query.offset = offset.toString();
@@ -730,7 +730,7 @@ class ApiClient {
             query.limit = limit.toString();
         return await this.request({
             method: 'GET',
-            path: `/workspaces/${encodeURIComponent(workspace)}/targets/execs/${encodeURIComponent(execId)}/log`,
+            path: `/workspaces/${encodeURIComponent(workspace)}/targets/${encodeURIComponent(targetId)}/execs/${encodeURIComponent(execId)}/log`,
             query,
             parseResponseBody: true,
         });

package/distTs/src/command/sandbox/fetch/add.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cliError_1 = __importDefault(require("../../../cliError"));
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const output_1 = __importDefault(require("../../../output"));
+const input_1 = __importDefault(require("../../../input"));
+const sandbox_1 = require("../../../types/sandbox");
+const fetchSource_1 = require("../fetchSource");
+const commandSandboxFetchAdd = (0, utils_1.newCommand)('add', texts_1.DESC_COMMAND_SANDBOX_FETCH_ADD, {
+    requiredScopes: [utils_1.REST_API_SCOPE.SANDBOX_WRITE],
+    examples: texts_1.EXAMPLE_SANDBOX_FETCH_ADD,
+});
+commandSandboxFetchAdd.alias('create');
+(0, utils_1.sandboxScopeOptions)(commandSandboxFetchAdd);
+commandSandboxFetchAdd.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxFetchAdd.option('--ref <ref>', texts_1.OPTION_SANDBOX_FETCH_REF);
+commandSandboxFetchAdd.option('--repository <url>', texts_1.OPTION_SANDBOX_FETCH_REPOSITORY);
+commandSandboxFetchAdd.option('--path <directory>', texts_1.OPTION_SANDBOX_FETCH_PATH);
+commandSandboxFetchAdd.option('--artifact <name:version>', texts_1.OPTION_SANDBOX_FETCH_ARTIFACT);
+commandSandboxFetchAdd.option('--source-path <path>', texts_1.OPTION_SANDBOX_FETCH_SOURCE_PATH);
+commandSandboxFetchAdd.option('--build <command>', texts_1.OPTION_SANDBOX_FETCH_BUILD);
+commandSandboxFetchAdd.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandSandboxFetchAdd.action(async (identifier, options) => {
+    if (options.artifact && (options.repository || options.ref)) {
+        output_1.default.exitError(new cliError_1.default('usage_error', texts_1.ERR_SANDBOX_FETCH_MIX_ARTIFACT));
+    }
+    if (options.sourcePath && !options.artifact) {
+        output_1.default.exitError(new cliError_1.default('usage_error', texts_1.ERR_SANDBOX_FETCH_SOURCE_PATH));
+    }
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    let type = sandbox_1.SANDBOX_FETCH.PROJECT_REPO;
+    if (options.artifact)
+        type = sandbox_1.SANDBOX_FETCH.ARTIFACT;
+    else if (options.repository)
+        type = sandbox_1.SANDBOX_FETCH.PUBLIC_REPO;
+    const body = { type };
+    if (options.repository)
+        body.repository = options.repository;
+    if (options.ref)
+        body.ref = options.ref;
+    if (options.path)
+        body.path = options.path;
+    if (options.artifact)
+        body.artifact = options.artifact;
+    if (options.sourcePath)
+        body.source_path = options.sourcePath;
+    if (options.build)
+        body.build_command = options.build;
+    const fetch = await client.addSandboxFetch(workspace, sandboxId, body);
+    // a fetch added to a stopped sandbox stays STALE until it is refetched
+    const path = (0, fetchSource_1.sandboxFetchPath)(fetch);
+    output_1.default.exitResult(options.format === 'json', fetch, fetch.status === sandbox_1.SANDBOX_FETCH_STATUS.STALE
+        ? (0, texts_1.TXT_SANDBOX_FETCH_ADDED_STALE)(identifier, path)
+        : (0, texts_1.TXT_SANDBOX_FETCH_ADDED)(path));
+});
+exports.default = commandSandboxFetchAdd;

package/distTs/src/command/sandbox/fetch/delete.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const output_1 = __importDefault(require("../../../output"));
+const input_1 = __importDefault(require("../../../input"));
+const fetchSource_1 = require("../fetchSource");
+const commandSandboxFetchDelete = (0, utils_1.newCommand)('delete', texts_1.DESC_COMMAND_SANDBOX_FETCH_DELETE, {
+    requiredScopes: [utils_1.REST_API_SCOPE.SANDBOX_WRITE],
+    examples: texts_1.EXAMPLE_SANDBOX_FETCH_DELETE,
+});
+commandSandboxFetchDelete.alias('rm');
+(0, utils_1.sandboxScopeOptions)(commandSandboxFetchDelete);
+commandSandboxFetchDelete.option('-f, --force', texts_1.OPTION_CONFIRM_FORCE);
+commandSandboxFetchDelete.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandSandboxFetchDelete.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxFetchDelete.argument('<fetch>', texts_1.OPTION_SANDBOX_FETCH_ARG);
+commandSandboxFetchDelete.action(async (identifier, fetchRef, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const fetch = await (0, fetchSource_1.resolveSandboxFetch)(client, workspace, sandboxId, fetchRef);
+    const json = options.format === 'json';
+    const confirmed = await output_1.default.confirmDestructive(options.force, (0, texts_1.TXT_SANDBOX_FETCH_DELETE_CONFIRM)(identifier, (0, fetchSource_1.sandboxFetchPath)(fetch)), json);
+    if (!confirmed)
+        output_1.default.exitResult(json, { deleted: null });
+    await client.deleteSandboxFetch(workspace, sandboxId, fetch.id);
+    output_1.default.exitResult(json, { deleted: fetch }, (0, texts_1.TXT_SANDBOX_FETCH_DELETED)((0, fetchSource_1.sandboxFetchPath)(fetch)));
+});
+exports.default = commandSandboxFetchDelete;

package/distTs/src/command/sandbox/fetch/get.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const output_1 = __importDefault(require("../../../output"));
+const input_1 = __importDefault(require("../../../input"));
+const sandbox_1 = require("../../../types/sandbox");
+const fetchSource_1 = require("../fetchSource");
+const commandSandboxFetchGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_SANDBOX_FETCH_GET, {
+    requiredScopes: [utils_1.REST_API_SCOPE.SANDBOX_READ],
+    examples: texts_1.EXAMPLE_SANDBOX_FETCH_GET,
+});
+(0, utils_1.sandboxScopeOptions)(commandSandboxFetchGet);
+commandSandboxFetchGet.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandSandboxFetchGet.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxFetchGet.argument('<fetch>', texts_1.OPTION_SANDBOX_FETCH_ARG);
+commandSandboxFetchGet.action(async (identifier, fetchRef, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const found = await (0, fetchSource_1.resolveSandboxFetch)(client, workspace, sandboxId, fetchRef);
+    // the single fetch endpoint is the one that measures behind/outdated
+    const f = await client.getSandboxFetch(workspace, sandboxId, found.id);
+    if (options.format === 'json') {
+        output_1.default.json(f);
+    }
+    else {
+        const isArtifact = f.type === sandbox_1.SANDBOX_FETCH.ARTIFACT;
+        const data = [
+            ['Field', 'Value'],
+            ['ID', f.id || '-'],
+            ['Type', f.type || '-'],
+            ['Path', (0, fetchSource_1.sandboxFetchPath)(f)],
+            ['Source', (0, fetchSource_1.sandboxFetchSource)(f)],
+            [isArtifact ? 'Version' : 'Ref', (0, fetchSource_1.sandboxFetchRefOrVersion)(f)],
+            ['Build command', f.build_command || '-'],
+            ['Status', f.status || '-'],
+            ['Revision', f.current_revision || '-'],
+            ['Behind', (0, fetchSource_1.sandboxFetchBehind)(f)],
+            ['Fetched', f.fetched_date || '-'],
+        ];
+        if (f.error_message)
+            data.push(['Error', f.error_message]);
+        output_1.default.table(data);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxFetchGet;

package/distTs/src/command/sandbox/fetch/list.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const output_1 = __importDefault(require("../../../output"));
+const input_1 = __importDefault(require("../../../input"));
+const fetchSource_1 = require("../fetchSource");
+const commandSandboxFetchList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_SANDBOX_FETCH_LIST, {
+    requiredScopes: [utils_1.REST_API_SCOPE.SANDBOX_READ],
+    examples: texts_1.EXAMPLE_SANDBOX_FETCH_LIST,
+});
+commandSandboxFetchList.alias('ls');
+(0, utils_1.sandboxScopeOptions)(commandSandboxFetchList);
+commandSandboxFetchList.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandSandboxFetchList.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxFetchList.action(async (identifier, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const response = await client.listSandboxFetches(workspace, sandboxId);
+    const fetches = response.fetches || [];
+    if (options.format === 'json') {
+        output_1.default.json(fetches);
+    }
+    else {
+        if (fetches.length === 0) {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_FETCHES_NOT_FOUND);
+        }
+        const data = [
+            ['ID', 'Path', 'Source', 'Ref/Version', 'Status', 'Revision', 'Behind'],
+        ];
+        for (const f of fetches) {
+            data.push([
+                f.id || '-',
+                (0, fetchSource_1.sandboxFetchPath)(f),
+                (0, fetchSource_1.sandboxFetchSource)(f),
+                (0, fetchSource_1.sandboxFetchRefOrVersion)(f),
+                f.status || '-',
+                (0, fetchSource_1.sandboxFetchRevision)(f),
+                (0, fetchSource_1.sandboxFetchBehind)(f),
+            ]);
+        }
+        output_1.default.table(data);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxFetchList;

package/distTs/src/command/sandbox/fetch/refetch.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const texts_1 = require("../../../texts");
+const output_1 = __importDefault(require("../../../output"));
+const input_1 = __importDefault(require("../../../input"));
+const fetchSource_1 = require("../fetchSource");
+const commandSandboxFetchRefetch = (0, utils_1.newCommand)('refetch', texts_1.DESC_COMMAND_SANDBOX_FETCH_REFETCH, {
+    requiredScopes: [utils_1.REST_API_SCOPE.SANDBOX_WRITE],
+    examples: texts_1.EXAMPLE_SANDBOX_FETCH_REFETCH,
+});
+(0, utils_1.sandboxScopeOptions)(commandSandboxFetchRefetch);
+commandSandboxFetchRefetch.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandSandboxFetchRefetch.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxFetchRefetch.argument('<fetch>', texts_1.OPTION_SANDBOX_FETCH_ARG);
+commandSandboxFetchRefetch.action(async (identifier, fetchRef, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const sandboxId = await input_1.default.sandboxId(client, workspace, options, identifier);
+    const found = await (0, fetchSource_1.resolveSandboxFetch)(client, workspace, sandboxId, fetchRef);
+    const fetch = await client.refetchSandboxFetch(workspace, sandboxId, found.id);
+    output_1.default.exitResult(options.format === 'json', fetch, (0, texts_1.TXT_SANDBOX_FETCH_REFETCHED)((0, fetchSource_1.sandboxFetchPath)(fetch)));
+});
+exports.default = commandSandboxFetchRefetch;

package/distTs/src/command/sandbox/fetch.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+const list_1 = __importDefault(require("./fetch/list"));
+const get_1 = __importDefault(require("./fetch/get"));
+const add_1 = __importDefault(require("./fetch/add"));
+const delete_1 = __importDefault(require("./fetch/delete"));
+const refetch_1 = __importDefault(require("./fetch/refetch"));
+const commandSandboxFetch = (0, utils_1.newCommand)('fetch', texts_1.DESC_COMMAND_SANDBOX_FETCH, {
+    examples: [
+        ...texts_1.EXAMPLE_SANDBOX_FETCH_LIST,
+        ...texts_1.EXAMPLE_SANDBOX_FETCH_GET,
+        ...texts_1.EXAMPLE_SANDBOX_FETCH_ADD,
+        ...texts_1.EXAMPLE_SANDBOX_FETCH_DELETE,
+        ...texts_1.EXAMPLE_SANDBOX_FETCH_REFETCH,
+    ],
+});
+commandSandboxFetch.alias('f');
+commandSandboxFetch.addCommand(list_1.default);
+commandSandboxFetch.addCommand(get_1.default);
+commandSandboxFetch.addCommand(add_1.default);
+commandSandboxFetch.addCommand(delete_1.default);
+commandSandboxFetch.addCommand(refetch_1.default);
+exports.default = commandSandboxFetch;

package/distTs/src/command/sandbox/fetchSource.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSandboxFetch = exports.resolveSandboxFetch = exports.sandboxFetchPath = exports.sandboxFetchRevision = exports.sandboxFetchRefOrVersion = exports.sandboxFetchBehind = exports.sandboxFetchSource = exports.SANDBOX_FETCH_DEFAULT = void 0;
+const cliError_1 = __importDefault(require("../../cliError"));
+const texts_1 = require("../../texts");
+const sandbox_1 = require("../../types/sandbox");
+exports.SANDBOX_FETCH_DEFAULT = ':default';
+// Where the files come from: the project repository, a public repository URL or
+// the artifact (with the path inside it when only part of it is fetched)
+const sandboxFetchSource = (f) => {
+    if (f.type === sandbox_1.SANDBOX_FETCH.ARTIFACT) {
+        const artifact = f.artifact || '-';
+        return f.source_path ? `${artifact} (${f.source_path})` : artifact;
+    }
+    if (f.type === sandbox_1.SANDBOX_FETCH.PUBLIC_REPO)
+        return f.repository || '-';
+    return 'project repository';
+};
+exports.sandboxFetchSource = sandboxFetchSource;
+// How far the fetched files are from what the fetch points at. Repositories count
+// commits behind the ref, artifacts only know whether the version moved on. Null
+// means the API could not measure it (e.g. an unreachable public repository).
+const sandboxFetchBehind = (f) => {
+    if (f.type === sandbox_1.SANDBOX_FETCH.ARTIFACT) {
+        if (f.outdated === true)
+            return 'outdated';
+        if (f.outdated === false)
+            return 'up to date';
+        return '-';
+    }
+    if (typeof f.behind !== 'number')
+        return '-';
+    if (f.behind === 0)
+        return 'up to date';
+    return `${f.behind} behind`;
+};
+exports.sandboxFetchBehind = sandboxFetchBehind;
+// The ref of a repository fetch, the version of an artifact fetch (name:version)
+const sandboxFetchRefOrVersion = (f) => {
+    if (f.type === sandbox_1.SANDBOX_FETCH.ARTIFACT) {
+        const artifact = f.artifact || '';
+        const idx = artifact.lastIndexOf(':');
+        return idx > 0 ? artifact.substring(idx + 1) : '-';
+    }
+    return f.ref || '-';
+};
+exports.sandboxFetchRefOrVersion = sandboxFetchRefOrVersion;
+const sandboxFetchRevision = (f) => f.current_revision ? f.current_revision.substring(0, 7) : '-';
+exports.sandboxFetchRevision = sandboxFetchRevision;
+// How a fetch is named in messages: its target directory, ":default" for the
+// fetch into the app directory (the API keeps its path empty)
+const sandboxFetchPath = (f) => f.path || exports.SANDBOX_FETCH_DEFAULT;
+exports.sandboxFetchPath = sandboxFetchPath;
+const trimSlash = (p) => (p || '').replace(/\/+$/, '');
+// The API ID or an explicitly set target directory, no app directory needed
+const matchSandboxFetch = (fetches, ref) => fetches.find((f) => f.id === ref) ||
+    fetches.find((f) => !!f.path && trimSlash(f.path) === trimSlash(ref));
+// Lists the sandbox fetches and picks one. The sandbox itself is read only when
+// the ref may name the app directory: ":default", or the directory given
+// explicitly for the fetch into it, which keeps an empty path
+const resolveSandboxFetch = async (client, workspace, sandboxId, ref) => {
+    const response = await client.listSandboxFetches(workspace, sandboxId);
+    const fetches = response.fetches || [];
+    let appDir;
+    if (!matchSandboxFetch(fetches, ref)) {
+        const sandbox = await client.getSandbox(workspace, sandboxId);
+        appDir = sandbox.app_dir;
+    }
+    return (0, exports.findSandboxFetch)(fetches, ref, appDir);
+};
+exports.resolveSandboxFetch = resolveSandboxFetch;
+// A fetch is identified by its target directory, ":default" (or the app directory
+// itself) names the one into the app directory. The API ID is accepted too, so
+// output of `list --format json` can be fed back directly.
+const findSandboxFetch = (fetches, ref, appDir) => {
+    let found = matchSandboxFetch(fetches, ref);
+    if (!found &&
+        (ref === exports.SANDBOX_FETCH_DEFAULT ||
+            (!!appDir && trimSlash(ref) === trimSlash(appDir)))) {
+        found = fetches.find((f) => !f.path || (!!appDir && trimSlash(f.path) === trimSlash(appDir)));
+    }
+    if (!found) {
+        throw new cliError_1.default('not_found', texts_1.ERR_SANDBOX_FETCH_NOT_FOUND, texts_1.HINT_SANDBOX_FETCH_LIST);
+    }
+    return found;
+};
+exports.findSandboxFetch = findSandboxFetch;

package/distTs/src/command/target/exec/command.js

@@ -47,18 +47,19 @@ commandTargetExecCommand.action(async (identifier, command, options) => {
         command: cmd,
     });
     const execId = exec.execution_id;
+    const target = (0, scope_1.targetExecRef)(identifier, options);
     const json = options.format === 'json';
     // Preserve the execution id before status validation can fail.
     if (!json) {
         if (options.async) {
-            output_1.default.note((0, texts_1.TXT_TARGET_EXEC_BACKGROUND)(execId));
+            output_1.default.note((0, texts_1.TXT_TARGET_EXEC_BACKGROUND)(target, execId));
             output_1.default.data(execId);
         }
         else {
             output_1.default.note((0, texts_1.TXT_TARGET_EXEC_ID)(execId));
         }
     }
-    const recoveryHint = (0, texts_1.TXT_TARGET_EXEC_RECOVERY)(execId);
+    const recoveryHint = (0, texts_1.TXT_TARGET_EXEC_RECOVERY)(target, execId);
     let code = options.exitCode
         ? (0, utils_1.executionExitCode)(exec.status, recoveryHint)
         : undefined;
@@ -71,12 +72,12 @@ commandTargetExecCommand.action(async (identifier, command, options) => {
     }
     if (json) {
         while (exec.status === utils_1.TARGET_EXEC_STATUS.INPROGRESS) {
-            exec = await client.getTargetExec(workspace, execId, EXEC_WAIT_MS);
+            exec = await client.getTargetExec(workspace, target_id, execId, EXEC_WAIT_MS);
             if (options.exitCode)
                 code = (0, utils_1.executionExitCode)(exec.status, recoveryHint);
         }
         const log = [];
-        await (0, scope_1.forwardExecLog)(client, workspace, execId, 0, (lines) => log.push(...lines));
+        await (0, scope_1.forwardExecLog)(client, workspace, target_id, execId, 0, (lines) => log.push(...lines));
         output_1.default.json({ ...exec, log });
         output_1.default.exitCode(code ?? (exec.status === utils_1.TARGET_EXEC_STATUS.SUCCESSFUL ? 0 : 1));
     }
@@ -87,12 +88,12 @@ commandTargetExecCommand.action(async (identifier, command, options) => {
     let loggedBytes;
     const drainLog = async () => {
         loggedBytes = exec.bytes_out;
-        const log = await (0, scope_1.forwardExecLog)(client, workspace, execId, offset);
+        const log = await (0, scope_1.forwardExecLog)(client, workspace, target_id, execId, offset);
         offset = log.offset;
         truncated = truncated || log.truncated;
     };
     while (exec.status === utils_1.TARGET_EXEC_STATUS.INPROGRESS) {
-        exec = await client.getTargetExec(workspace, execId, EXEC_WAIT_MS);
+        exec = await client.getTargetExec(workspace, target_id, execId, EXEC_WAIT_MS);
         if (options.exitCode)
             (0, utils_1.executionExitCode)(exec.status, recoveryHint);
         if (exec.bytes_out !== loggedBytes)
@@ -105,11 +106,11 @@ commandTargetExecCommand.action(async (identifier, command, options) => {
         output_1.default.noteWarning(texts_1.WARN_TARGET_EXEC_TRUNCATED);
     }
     if (exec.status === utils_1.TARGET_EXEC_STATUS.SUCCESSFUL) {
-        output_1.default.note((0, texts_1.TXT_TARGET_EXEC_SUCCESS)(execId));
+        output_1.default.note((0, texts_1.TXT_TARGET_EXEC_SUCCESS)(target, execId));
         output_1.default.exitNormal();
     }
     output_1.default.exitError(exec.status === utils_1.TARGET_EXEC_STATUS.CANCELLED
-        ? (0, texts_1.TXT_TARGET_EXEC_CANCELLED)(execId)
-        : (0, texts_1.TXT_TARGET_EXEC_FAILED)(execId, exec.failure_reason), 1);
+        ? (0, texts_1.TXT_TARGET_EXEC_CANCELLED)(target, execId)
+        : (0, texts_1.TXT_TARGET_EXEC_FAILED)(target, execId, exec.failure_reason), 1);
 });
 exports.default = commandTargetExecCommand;

package/distTs/src/command/target/exec/kill.js

@@ -7,25 +7,31 @@ const utils_1 = require("../../../utils");
 const texts_1 = require("../../../texts");
 const input_1 = __importDefault(require("../../../input"));
 const output_1 = __importDefault(require("../../../output"));
+const scope_1 = require("../scope");
 const commandTargetExecKill = (0, utils_1.newCommand)('kill', texts_1.DESC_COMMAND_TARGET_EXEC_KILL, { requiredScopes: [utils_1.REST_API_SCOPE.TARGET_USE], examples: texts_1.EXAMPLE_TARGET_EXEC_KILL });
 commandTargetExecKill.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetExecKill.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetExecKill.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetExecKill.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
 commandTargetExecKill.option('-f, --force', texts_1.OPTION_CONFIRM_FORCE);
 commandTargetExecKill.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandTargetExecKill.argument('<identifier>', texts_1.OPTION_TARGET_IDENTIFIER);
 commandTargetExecKill.argument('<exec-id>', texts_1.OPTION_TARGET_EXEC_ID);
-commandTargetExecKill.action(async (execId, options) => {
+commandTargetExecKill.action(async (identifier, execId, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
     const client = input_1.default.restApiTokenClient();
+    const target_id = await (0, scope_1.resolveTargetId)(client, workspace, identifier, options);
     // Resolve the exec before the prompt so a bad id fails the same way
     // (Resource not found, exit 1) with and without --force - otherwise the
     // confirmation error would hide the invalid id. With --force
     // the DELETE itself surfaces the 404, so the extra request is skipped.
     if (!options.force)
-        await client.getTargetExec(workspace, execId);
+        await client.getTargetExec(workspace, target_id, execId);
     const json = options.format === 'json';
     const confirmed = await output_1.default.confirmDestructive(options.force, (0, texts_1.TXT_TARGET_EXEC_KILL_CONFIRM)(execId), json);
     if (!confirmed)
         output_1.default.exitResult(json, { killed: null });
-    await client.cancelTargetExec(workspace, execId);
+    await client.cancelTargetExec(workspace, target_id, execId);
     output_1.default.exitResult(json, { killed: execId }, (0, texts_1.TXT_TARGET_EXEC_KILLED)(execId));
 });
 exports.default = commandTargetExecKill;

package/distTs/src/command/target/exec/logs.js

@@ -10,23 +10,28 @@ const output_1 = __importDefault(require("../../../output"));
 const scope_1 = require("../scope");
 const commandTargetExecLogs = (0, utils_1.newCommand)('logs', texts_1.DESC_COMMAND_TARGET_EXEC_LOGS, { requiredScopes: [utils_1.REST_API_SCOPE.TARGET_READ], helpText: texts_1.HELP_TARGET_EXEC_LOGS_JSONL, examples: texts_1.EXAMPLE_TARGET_EXEC_LOGS });
 commandTargetExecLogs.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetExecLogs.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetExecLogs.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetExecLogs.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
 commandTargetExecLogs.option('--offset <n>', texts_1.OPTION_TARGET_EXEC_LOG_OFFSET);
 commandTargetExecLogs.option('--limit <n>', texts_1.OPTION_TARGET_EXEC_LOG_LIMIT);
+commandTargetExecLogs.argument('<identifier>', texts_1.OPTION_TARGET_IDENTIFIER);
 commandTargetExecLogs.argument('<exec-id>', texts_1.OPTION_TARGET_EXEC_ID);
 commandTargetExecLogs.option('--format <text|jsonl>', texts_1.OPTION_EXEC_FORMAT_JSONL);
 commandTargetExecLogs.option('--exit-code', texts_1.OPTION_EXEC_EXIT_CODE);
-commandTargetExecLogs.action(async (execId, options) => {
+commandTargetExecLogs.action(async (identifier, execId, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
     const client = input_1.default.restApiTokenClient();
+    const target_id = await (0, scope_1.resolveTargetId)(client, workspace, identifier, options);
     const offset = options.offset ? parseInt(options.offset, 10) : 0;
     const limit = options.limit ? parseInt(options.limit, 10) : undefined;
-    const { truncated } = await (0, scope_1.forwardExecLog)(client, workspace, execId, offset, options.format === 'jsonl'
+    const { truncated } = await (0, scope_1.forwardExecLog)(client, workspace, target_id, execId, offset, options.format === 'jsonl'
         ? (lines) => lines.forEach((data) => output_1.default.json({ type: 'log', data }))
         : undefined, limit);
     if (truncated)
         output_1.default.noteWarning(texts_1.WARN_TARGET_EXEC_TRUNCATED);
     if (options.format === 'jsonl' || options.exitCode) {
-        const exec = await client.getTargetExec(workspace, execId);
+        const exec = await client.getTargetExec(workspace, target_id, execId);
         const code = options.exitCode ? (0, utils_1.executionExitCode)(exec.status) : undefined;
         if (options.format === 'jsonl')
             output_1.default.json({

package/distTs/src/command/target/exec/status.js

@@ -7,15 +7,21 @@ const utils_1 = require("../../../utils");
 const texts_1 = require("../../../texts");
 const input_1 = __importDefault(require("../../../input"));
 const output_1 = __importDefault(require("../../../output"));
+const scope_1 = require("../scope");
 const commandTargetExecStatus = (0, utils_1.newCommand)('status', texts_1.DESC_COMMAND_TARGET_EXEC_STATUS, { requiredScopes: [utils_1.REST_API_SCOPE.TARGET_READ], examples: texts_1.EXAMPLE_TARGET_EXEC_STATUS, helpText: texts_1.HELP_TARGET_EXEC_STATUS });
 commandTargetExecStatus.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetExecStatus.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetExecStatus.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetExecStatus.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
 commandTargetExecStatus.option('--format <text|json>', texts_1.OPTION_EXEC_FORMAT_JSON);
+commandTargetExecStatus.argument('<identifier>', texts_1.OPTION_TARGET_IDENTIFIER);
 commandTargetExecStatus.argument('<exec-id>', texts_1.OPTION_TARGET_EXEC_ID);
 commandTargetExecStatus.option('--exit-code', texts_1.OPTION_EXEC_EXIT_CODE);
-commandTargetExecStatus.action(async (execId, options) => {
+commandTargetExecStatus.action(async (identifier, execId, options) => {
     const workspace = input_1.default.restApiWorkspace(options.workspace);
     const client = input_1.default.restApiTokenClient();
-    const exec = await client.getTargetExec(workspace, execId);
+    const target_id = await (0, scope_1.resolveTargetId)(client, workspace, identifier, options);
+    const exec = await client.getTargetExec(workspace, target_id, execId);
     const code = options.exitCode ? (0, utils_1.executionExitCode)(exec.status) : undefined;
     if (options.format === 'json') {
         output_1.default.json(exec);

package/distTs/src/command/target/scope.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveTargetScope = exports.targetScopeOf = exports.targetAddressOf = exports.forwardExecLog = exports.resolveTargetId = void 0;
+exports.resolveTargetScope = exports.targetScopeOf = exports.targetAddressOf = exports.forwardExecLog = exports.targetExecRef = exports.resolveTargetId = void 0;
 const utils_1 = require("../../utils");
 const texts_1 = require("../../texts");
 const output_1 = __importDefault(require("../../output"));
@@ -18,10 +18,11 @@ const input_1 = __importDefault(require("../../input"));
 // line - that is how workspace targets stay addressable from a line context,
 // which the CLI enters on its own from BUDDY_PROJECT or a linked project.
 //
-// strictLine is for mutating commands (update/delete/exec command): an
-// explicit line flag is a statement "the target of this project/pipeline/
-// environment", so no fallback, and the scope is verified once more in case
-// the API resolves loosely again.
+// strictLine is for commands that act on the target itself (update/delete/
+// exec command): the requested line - from a flag, BUDDY_PROJECT or a linked
+// project alike - is a statement "the target of this project/pipeline/
+// environment", so no fallback. An explicit flag additionally gets the scope
+// verified once more in case the API resolves loosely again.
 const resolveTargetId = async (client, workspace, identifier, options, strictLine = false) => {
     const project = input_1.default.restApiProject(options.project, true);
     const line = input_1.default.targetLine(project, options.pipeline, options.environment);
@@ -57,6 +58,24 @@ const resolveTargetId = async (client, workspace, identifier, options, strictLin
     return resolved.target_id;
 };
 exports.resolveTargetId = resolveTargetId;
+// Executions live under their target, so follow-up commands printed in hints
+// need the target again - with the line it was resolved through, or a
+// project/pipeline/environment target would not resolve on the next call.
+// The project is the one resolveTargetId used, so one implied by
+// BUDDY_PROJECT or a linked directory is spelled out: the hint has to work
+// from another shell or directory too.
+const targetExecRef = (identifier, options) => {
+    let ref = identifier;
+    const project = input_1.default.restApiProject(options.project, true);
+    if (project)
+        ref += ` -p ${project}`;
+    if (options.pipeline)
+        ref += ` --pipeline ${options.pipeline}`;
+    if (options.environment)
+        ref += ` --environment ${options.environment}`;
+    return ref;
+};
+exports.targetExecRef = targetExecRef;
 // Lines the CLI requests per log fetch.
 const EXEC_LOG_PAGE = 1000;
 // The exec log endpoint pages by line offset; its `truncated` field
@@ -66,7 +85,7 @@ const EXEC_LOG_PAGE = 1000;
 // next_offset - offset lines are emitted to avoid re-printing the partial
 // line on the next pass. A page shorter than requested means the committed
 // log is drained, so the common case costs a single request.
-const forwardExecLog = async (client, workspace, execId, startOffset, emitPage = (lines) => output_1.default.data(lines.join('\n')), maxLines) => {
+const forwardExecLog = async (client, workspace, targetId, execId, startOffset, emitPage = (lines) => output_1.default.data(lines.join('\n')), maxLines) => {
     let offset = startOffset;
     let emitted = 0;
     let truncated = false;
@@ -76,7 +95,7 @@ const forwardExecLog = async (client, workspace, execId, startOffset, emitPage =
             : Math.min(EXEC_LOG_PAGE, maxLines - emitted);
         if (pageLimit <= 0)
             break;
-        const log = await client.getTargetExecLog(workspace, execId, offset, pageLimit);
+        const log = await client.getTargetExecLog(workspace, targetId, execId, offset, pageLimit);
         truncated = truncated || !!log.truncated;
         const next = log.next_offset ?? offset;
         if (next <= offset)

package/distTs/src/texts.js

@@ -502,7 +502,7 @@ exports.OPTION_EXEC_FORMAT_JSONL = 'Output format: jsonl, text. JSONL CLI errors
 exports.OPTION_EXEC_FORMAT_JSON = 'Output format: json, text. JSON CLI errors: {error:{code,message,hint}}, exit 1 (2 or 3 with --exit-code). Default: text';
 const ERR_EXEC_STATUS_UNKNOWN = (status) => `Unknown execution status: ${status ?? '(missing)'}`;
 exports.ERR_EXEC_STATUS_UNKNOWN = ERR_EXEC_STATUS_UNKNOWN;
-const TXT_TARGET_EXEC_RECOVERY = (id) => `Execution ID: ${id}. Run 'bdy target exec logs ${id}' to read logs.`;
+const TXT_TARGET_EXEC_RECOVERY = (target, id) => `Execution ID: ${id}. Run 'bdy target exec logs ${target} ${id}' to read logs.`;
 exports.TXT_TARGET_EXEC_RECOVERY = TXT_TARGET_EXEC_RECOVERY;
 const ERR_PIPELINE_RUN_STATUS_UNKNOWN = (status) => `Unknown pipeline run status: ${status ?? '(missing)'}`;
 exports.ERR_PIPELINE_RUN_STATUS_UNKNOWN = ERR_PIPELINE_RUN_STATUS_UNKNOWN;
@@ -1124,18 +1124,18 @@ exports.TXT_TARGET_DELETED = TXT_TARGET_DELETED;
 // Target exec messages
 const TXT_TARGET_EXEC_ID = (id) => `Execution id: ${id}`;
 exports.TXT_TARGET_EXEC_ID = TXT_TARGET_EXEC_ID;
-const TXT_TARGET_EXEC_BACKGROUND = (execId) => `Command started in background: ${execId}. To view status or logs of the execution run:
-  bdy tg exec status ${execId}
-  bdy tg exec logs ${execId}`;
+const TXT_TARGET_EXEC_BACKGROUND = (target, execId) => `Command started in background: ${execId}. To view status or logs of the execution run:
+  bdy tg exec status ${target} ${execId}
+  bdy tg exec logs ${target} ${execId}`;
 exports.TXT_TARGET_EXEC_BACKGROUND = TXT_TARGET_EXEC_BACKGROUND;
-const TXT_TARGET_EXEC_SUCCESS = (execId) => `Command finished successfully: ${execId}. To view logs of the execution run:
-  bdy tg exec logs ${execId}`;
+const TXT_TARGET_EXEC_SUCCESS = (target, execId) => `Command finished successfully: ${execId}. To view logs of the execution run:
+  bdy tg exec logs ${target} ${execId}`;
 exports.TXT_TARGET_EXEC_SUCCESS = TXT_TARGET_EXEC_SUCCESS;
-const TXT_TARGET_EXEC_FAILED = (execId, reason) => `Command failed${reason ? ` (${reason})` : ''}: ${execId}. To view logs of the execution run:
-  bdy tg exec logs ${execId}`;
+const TXT_TARGET_EXEC_FAILED = (target, execId, reason) => `Command failed${reason ? ` (${reason})` : ''}: ${execId}. To view logs of the execution run:
+  bdy tg exec logs ${target} ${execId}`;
 exports.TXT_TARGET_EXEC_FAILED = TXT_TARGET_EXEC_FAILED;
-const TXT_TARGET_EXEC_CANCELLED = (execId) => `Command cancelled: ${execId}. To view logs of the execution run:
-  bdy tg exec logs ${execId}`;
+const TXT_TARGET_EXEC_CANCELLED = (target, execId) => `Command cancelled: ${execId}. To view logs of the execution run:
+  bdy tg exec logs ${target} ${execId}`;
 exports.TXT_TARGET_EXEC_CANCELLED = TXT_TARGET_EXEC_CANCELLED;
 exports.WARN_TARGET_EXEC_TRUNCATED = 'Command output was truncated by the server';
 const TXT_TARGET_EXEC_KILL_CONFIRM = (execId) => `Are you sure you want to cancel execution '${execId}'?`;
@@ -2166,21 +2166,21 @@ exports.EXAMPLE_TARGET_EXEC_COMMAND = [
 exports.EXAMPLE_TARGET_EXEC_STATUS = [
     {
         description: 'return the execution state using semantic exit codes',
-        command: 'bdy target exec status exec-id --exit-code',
+        command: 'bdy target exec status target-identifier exec-id --exit-code',
     },
     {
         description: 'show status of execution:',
-        command: 'bdy tg exec status exec-id',
+        command: 'bdy tg exec status target-identifier exec-id',
     },
 ];
 exports.EXAMPLE_TARGET_EXEC_KILL = [
     {
         description: 'cancel running execution:',
-        command: 'bdy tg exec kill exec-id',
+        command: 'bdy tg exec kill target-identifier exec-id',
     },
     {
         description: 'cancel running execution and automatically confirm:',
-        command: 'bdy tg exec kill exec-id -f',
+        command: 'bdy tg exec kill target-identifier exec-id -f',
     },
 ];
 exports.EXAMPLE_TARGET_EXEC_LIST = [
@@ -2196,19 +2196,19 @@ exports.EXAMPLE_TARGET_EXEC_LIST = [
 exports.EXAMPLE_TARGET_EXEC_LOGS = [
     {
         description: 'return the execution state using semantic exit codes',
-        command: 'bdy target exec logs exec-id --exit-code',
+        command: 'bdy target exec logs target-identifier exec-id --exit-code',
     },
     {
         description: 'show logs of execution:',
-        command: 'bdy tg exec logs exec-id',
+        command: 'bdy tg exec logs target-identifier exec-id',
     },
     {
         description: 'show logs of execution starting from line 100:',
-        command: 'bdy tg exec logs exec-id --offset 100',
+        command: 'bdy tg exec logs target-identifier exec-id --offset 100',
     },
     {
         description: 'Return log records as JSONL',
-        command: 'bdy target exec logs execution-id --format jsonl',
+        command: 'bdy target exec logs target-identifier execution-id --format jsonl',
     },
 ];
 exports.EXAMPLE_ENVIRONMENT_LIST = [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.25.21-dev",
+  "version": "1.25.22-master",
   "type": "commonjs",
   "license": "MIT",
   "homepage": "https://buddy.works/docs/cli",