bdy 1.16.11-master → 1.16.11-sbs-1

package/distTs/src/command/package/publish.js

@@ -0,0 +1,231 @@
+"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 input_1 = __importDefault(require("../../input"));
+const client_1 = __importDefault(require("../../api/client"));
+const output_1 = __importDefault(require("../../output"));
+const logger_1 = __importDefault(require("../../logger"));
+const fflate_1 = __importDefault(require("fflate"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const uuid_1 = require("uuid");
+const commandPackagePublish = (0, utils_1.newCommand)('publish', texts_1.DESC_COMMAND_PACKAGE_PUBLISH);
+commandPackagePublish.alias('pub');
+commandPackagePublish.option('-t, --token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandPackagePublish.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandPackagePublish.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandPackagePublish.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandPackagePublish.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandPackagePublish.option('-c, --create', texts_1.OPTION_PACKAGE_PUBLISH_CREATE);
+commandPackagePublish.option('-f, --force', texts_1.OPTION_PACKAGE_PUBLISH_OVERWRITE_VERSION);
+commandPackagePublish.argument('<identifier>', texts_1.OPTION_PACKAGE_ID);
+commandPackagePublish.argument('<directory>', texts_1.OPTION_PACKAGE_PUBLISH_PATH);
+commandPackagePublish.action(async (id, path, options) => {
+    let dirPath = input_1.default.resolvePath(path);
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project, true);
+    // eslint-disable-next-line prefer-const
+    let { identifier, version } = input_1.default.packageSplitIdentifier(id);
+    if (!version)
+        version = (0, uuid_1.v4)();
+    const client = new client_1.default(baseUrl, token);
+    const data = await client.getPackageVersionByIdentifier(workspace, project, identifier, version);
+    if (!data || !data.domain) {
+        output_1.default.exitError(texts_1.ERR_WORKSPACE_NOT_FOUND);
+    }
+    if (project && !data.project_identifier) {
+        output_1.default.exitError(texts_1.ERR_PROJECT_NOT_FOUND);
+    }
+    let packageId = data.pkg_id;
+    if (!packageId) {
+        if (options.create) {
+            const d = await client.postPackage(workspace, project, identifier);
+            packageId = d.id;
+        }
+        else {
+            output_1.default.exitError(texts_1.ERR_PACKAGE_PUBLISH_NOT_FOUND);
+        }
+    }
+    let packageVersionId = data.pkg_version_id;
+    let url;
+    if (packageVersionId && !options.force) {
+        output_1.default.exitError(texts_1.ERR_PACKAGE_VERSION_EXISTS);
+    }
+    if (!packageVersionId) {
+        const d = await client.postPackageVersion(workspace, packageId, version);
+        url = d.version_url;
+        packageVersionId = d.id;
+    }
+    else {
+        const d = await client.getPackageVersion(workspace, packageId, packageVersionId);
+        url = d.version_url;
+    }
+    output_1.default.normal(texts_1.TXT_PACKAGE_SCANNING_DIR, false);
+    const stat = fs_1.default.statSync(dirPath);
+    let entries;
+    if (stat.isDirectory()) {
+        entries = fs_1.default.readdirSync(dirPath, {
+            withFileTypes: true,
+            recursive: true,
+        });
+    }
+    else {
+        const parentPath = (0, path_1.dirname)(dirPath);
+        entries = [
+            {
+                isDirectory: () => stat.isDirectory(),
+                isFile: () => stat.isFile(),
+                isBlockDevice: () => stat.isBlockDevice(),
+                isCharacterDevice: () => stat.isCharacterDevice(),
+                isFIFO: () => stat.isFIFO(),
+                isSocket: () => stat.isSocket(),
+                isSymbolicLink: () => stat.isSymbolicLink(),
+                name: (0, path_1.basename)(dirPath),
+                parentPath,
+                path: parentPath,
+            },
+        ];
+        dirPath = parentPath;
+    }
+    if (!entries.length) {
+        output_1.default.normal(texts_1.TXT_PACKAGE_NO_ENTRIES_FOUND);
+        output_1.default.exitSuccess((0, texts_1.TXT_PACKAGE_PUBLISHED)(url));
+    }
+    else if (entries.length === 1) {
+        output_1.default.normal(texts_1.TXT_PACKAGE_ONE_ENTRY_FOUND);
+    }
+    else {
+        output_1.default.normal((0, texts_1.TXT_PACKAGE_ENTRIES_FOUND)(entries.length));
+    }
+    output_1.default.normal((0, texts_1.TXT_PACKAGE_ZIP_ENTRIES)(0));
+    const zipPath = (0, path_1.join)((0, utils_1.getHomeDirectory)(), `${(0, uuid_1.v4)()}.zip`);
+    const clearZip = () => {
+        try {
+            fs_1.default.rmSync(zipPath);
+        }
+        catch {
+            // do nothing
+        }
+    };
+    let blob;
+    try {
+        let proc = 0;
+        await createZip(dirPath, zipPath, entries, () => {
+            proc += 1;
+            output_1.default.clearPreviousLine();
+            output_1.default.normal((0, texts_1.TXT_PACKAGE_ZIP_ENTRIES)(proc));
+        });
+        output_1.default.clearPreviousLine();
+        output_1.default.normal(texts_1.TXT_PACKAGE_ZIPPED);
+        blob = await fs_1.default.openAsBlob(zipPath);
+    }
+    catch (err) {
+        logger_1.default.error(err);
+        clearZip();
+        output_1.default.exitError(texts_1.ERR_SWW);
+    }
+    try {
+        output_1.default.normal(texts_1.TXT_PACKAGE_UPLOADING);
+        await client.postPackageVersionZip(workspace, packageId, packageVersionId, blob);
+        output_1.default.clearPreviousLine();
+        output_1.default.normal(texts_1.TXT_PACKAGE_UPLOADED);
+        clearZip();
+        output_1.default.exitSuccess((0, texts_1.TXT_PACKAGE_PUBLISHED)(url));
+    }
+    catch (err) {
+        clearZip();
+        logger_1.default.error(err);
+        output_1.default.exitError(err);
+    }
+});
+const addEntryToZip = (dirPath, zip, entry) => {
+    return new Promise((resolve, reject) => {
+        const isDir = entry.isDirectory();
+        let name = (0, path_1.join)(entry.parentPath.replace(dirPath, ''), entry.name);
+        if (isDir)
+            name += '/';
+        const file = new fflate_1.default.AsyncZipDeflate(name, {
+            level: 9,
+        });
+        zip.add(file);
+        if (isDir) {
+            file.push(new Uint8Array(0), true);
+            resolve();
+            return;
+        }
+        const fullPath = (0, path_1.join)(entry.parentPath, entry.name);
+        const rs = fs_1.default.createReadStream(fullPath);
+        const finish = (err) => {
+            try {
+                rs.removeAllListeners();
+                rs.close();
+            }
+            catch {
+                // do nothing
+            }
+            if (err)
+                reject(err);
+            else
+                resolve();
+        };
+        rs.on('data', (chunk) => {
+            file.push(chunk, false);
+        });
+        rs.on('error', (err) => {
+            finish(err);
+        });
+        rs.on('end', () => {
+            file.push(new Uint8Array(0), true);
+            finish();
+        });
+    });
+};
+const addEntriesToZip = async (dirPath, zip, entries, onEntry) => {
+    for (let i = 0; i < entries.length; i += 1) {
+        await addEntryToZip(dirPath, zip, entries[i]);
+        onEntry();
+    }
+};
+const createZip = (dirPath, zipPath, entries, onEntry) => {
+    return new Promise((resolve, reject) => {
+        const ws = fs_1.default.createWriteStream(zipPath);
+        let wasError = false;
+        const zip = new fflate_1.default.Zip((err, data, final) => {
+            if (wasError) {
+                // do nothing
+            }
+            else if (err) {
+                wasError = true;
+                ws.close();
+                reject(err);
+            }
+            else {
+                ws.write(data);
+                if (final) {
+                    ws.close((err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                }
+            }
+        });
+        addEntriesToZip(dirPath, zip, entries, onEntry)
+            .then(() => {
+            zip.end();
+        })
+            .catch((err) => {
+            ws.close(() => {
+                reject(err);
+            });
+        });
+    });
+};
+exports.default = commandPackagePublish;

package/distTs/src/command/package.js

@@ -0,0 +1,14 @@
+"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 publish_1 = __importDefault(require("./package/publish"));
+const download_1 = __importDefault(require("./package/download"));
+const commandPackage = (0, utils_1.newCommand)('package', texts_1.DESC_COMMAND_PACKAGE);
+commandPackage.alias('pkg');
+commandPackage.addCommand(publish_1.default);
+commandPackage.addCommand(download_1.default);
+exports.default = commandPackage;

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

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cfg_1 = __importDefault(require("../../tunnel/cfg"));
+const output_1 = __importDefault(require("../../output"));
+const client_1 = __importDefault(require("../../api/client"));
+const texts_1 = require("../../texts");
+const utils_1 = require("../../utils");
+const commandProjectList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_PROJECT_LIST);
+commandProjectList.alias('ls');
+commandProjectList.action(async () => {
+    const token = cfg_1.default.getToken();
+    if (!token) {
+        output_1.default.exitError(texts_1.ERR_WORKSPACE_NOT_LOGGED_IN);
+    }
+    const workspace = cfg_1.default.getWorkspace();
+    if (!workspace) {
+        output_1.default.exitError(texts_1.TXT_WORKSPACE_NONE);
+    }
+    const baseUrl = cfg_1.default.getBaseUrl();
+    const region = cfg_1.default.getRegion();
+    const currentProject = cfg_1.default.getProject();
+    let apiUrl;
+    if (baseUrl) {
+        apiUrl = baseUrl;
+    }
+    else if (region?.toLowerCase() === 'eu') {
+        apiUrl = 'api.eu.buddy.works';
+    }
+    else {
+        apiUrl = 'api.buddy.works';
+    }
+    try {
+        const client = new client_1.default(new URL(`https://${apiUrl}`), token);
+        const response = await client.getProjects(workspace);
+        if (!response.projects || response.projects.length === 0) {
+            output_1.default.exitError(texts_1.ERR_PROJECT_NO_PROJECTS);
+        }
+        const data = [['NAME', 'DISPLAY NAME', 'STATUS', '']];
+        for (const proj of response.projects) {
+            const isCurrent = proj.name === currentProject;
+            data.push([
+                proj.name,
+                proj.display_name,
+                proj.status,
+                isCurrent ? '(current)' : '',
+            ]);
+        }
+        output_1.default.table(data);
+        if (currentProject) {
+            output_1.default.normal(`\n${(0, texts_1.TXT_PROJECT_CURRENT)(currentProject)}`);
+        }
+        process.exit(0);
+    }
+    catch (err) {
+        output_1.default.exitError(err);
+    }
+});
+exports.default = commandProjectList;

package/distTs/src/command/project/set.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const termkit_no_lazy_require_1 = __importDefault(require("terminal-kit/lib/termkit-no-lazy-require"));
+const cfg_1 = __importDefault(require("../../tunnel/cfg"));
+const output_1 = __importDefault(require("../../output"));
+const client_1 = __importDefault(require("../../api/client"));
+const texts_1 = require("../../texts");
+const utils_1 = require("../../utils");
+const terminal = termkit_no_lazy_require_1.default.terminal;
+// Handle Ctrl+C and ESC
+terminal.on('key', (key) => {
+    if (key === 'CTRL_C' || key === 'ESCAPE') {
+        terminal.grabInput(false);
+        terminal('\nCanceled\n');
+        process.exit(0);
+    }
+});
+async function selectProject(projects, currentName) {
+    terminal(`${texts_1.TXT_PROJECT_SELECT}\n`);
+    const items = projects.map((p) => {
+        const isCurrent = p.name === currentName;
+        return `${p.display_name} (${p.name})${isCurrent ? ' (current)' : ''}`;
+    });
+    return new Promise((resolve) => {
+        terminal.singleColumnMenu(items, (error, response) => {
+            terminal('\n');
+            resolve(projects[response.selectedIndex]);
+        });
+    });
+}
+const commandProjectSet = (0, utils_1.newCommand)('set', texts_1.DESC_COMMAND_PROJECT_SET);
+commandProjectSet.argument('[project]', 'Project name to set');
+commandProjectSet.action(async (projectName) => {
+    const token = cfg_1.default.getToken();
+    if (!token) {
+        output_1.default.exitError(texts_1.ERR_WORKSPACE_NOT_LOGGED_IN);
+    }
+    const workspace = cfg_1.default.getWorkspace();
+    if (!workspace) {
+        output_1.default.exitError(texts_1.TXT_WORKSPACE_NONE);
+    }
+    const baseUrl = cfg_1.default.getBaseUrl();
+    const region = cfg_1.default.getRegion();
+    const currentProject = cfg_1.default.getProject();
+    let apiUrl;
+    if (baseUrl) {
+        apiUrl = baseUrl;
+    }
+    else if (region?.toLowerCase() === 'eu') {
+        apiUrl = 'api.eu.buddy.works';
+    }
+    else {
+        apiUrl = 'api.buddy.works';
+    }
+    try {
+        const client = new client_1.default(new URL(`https://${apiUrl}`), token);
+        const response = await client.getProjects(workspace);
+        if (!response.projects || response.projects.length === 0) {
+            output_1.default.exitError(texts_1.ERR_PROJECT_NO_PROJECTS);
+        }
+        let selectedProject;
+        if (projectName) {
+            // Project provided as argument
+            const found = response.projects.find((p) => p.name === projectName);
+            if (!found) {
+                output_1.default.exitError((0, texts_1.ERR_PROJECT_NOT_FOUND)(projectName));
+            }
+            selectedProject = found;
+        }
+        else {
+            // Interactive selection
+            selectedProject = await selectProject(response.projects, currentProject);
+        }
+        cfg_1.default.setProject(selectedProject.name);
+        output_1.default.exitSuccess((0, texts_1.TXT_PROJECT_SET_SUCCESS)(selectedProject.name));
+    }
+    catch (err) {
+        output_1.default.exitError(err);
+    }
+});
+exports.default = commandProjectSet;

package/distTs/src/command/project.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const texts_1 = require("../texts");
+const utils_1 = require("../utils");
+const list_1 = __importDefault(require("./project/list"));
+const set_1 = __importDefault(require("./project/set"));
+const commandProject = (0, utils_1.newCommand)('project', texts_1.DESC_COMMAND_PROJECT);
+commandProject.alias('proj');
+commandProject.addCommand(list_1.default);
+commandProject.addCommand(set_1.default);
+exports.default = commandProject;

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

@@ -0,0 +1,35 @@
+"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 client_1 = __importDefault(require("../../../api/client"));
+const commandSandboxCommandKill = (0, utils_1.newCommand)('kill', texts_1.DESC_COMMAND_SANDBOX_COMMAND_KILL);
+commandSandboxCommandKill.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxCommandKill.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxCommandKill.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxCommandKill.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxCommandKill.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxCommandKill.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxCommandKill.argument('<command-id>', texts_1.OPTION_SANDBOX_COMMAND_ID);
+commandSandboxCommandKill.action(async (identifier, commandId, options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = new client_1.default(baseUrl, token);
+    // Find sandbox by identifier
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    await client.terminateSandboxCommand(workspace, found.id, commandId);
+    output_1.default.exitSuccess((0, texts_1.TXT_SANDBOX_COMMAND_KILLED)(commandId));
+});
+exports.default = commandSandboxCommandKill;

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

@@ -0,0 +1,54 @@
+"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 client_1 = __importDefault(require("../../../api/client"));
+const commandSandboxCommandList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_SANDBOX_COMMAND_LIST);
+commandSandboxCommandList.alias('ls');
+commandSandboxCommandList.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxCommandList.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxCommandList.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxCommandList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxCommandList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxCommandList.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxCommandList.action(async (identifier, options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = new client_1.default(baseUrl, token);
+    // Find sandbox by identifier
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    const commandsResult = await client.listSandboxCommands(workspace, found.id);
+    const commands = commandsResult.commands || [];
+    if (commands.length === 0) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NO_COMMANDS);
+    }
+    // Sort by ID descending (IDs are timestamp-based, so newest first)
+    commands.sort((a, b) => (b.id || '').localeCompare(a.id || ''));
+    const data = [
+        ['ID', 'COMMAND', 'STATUS', 'EXIT CODE', 'RUNTIME'],
+    ];
+    for (const cmd of commands) {
+        data.push([
+            cmd.id || '-',
+            (cmd.command || '-').substring(0, 40) + (cmd.command?.length > 40 ? '...' : ''),
+            cmd.status || '-',
+            cmd.exit_code !== undefined ? String(cmd.exit_code) : '-',
+            cmd.runtime || 'BASH',
+        ]);
+    }
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxCommandList;

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

@@ -0,0 +1,133 @@
+"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 client_1 = __importDefault(require("../../../api/client"));
+const commandSandboxCommandLogs = (0, utils_1.newCommand)('logs', texts_1.DESC_COMMAND_SANDBOX_COMMAND_LOGS);
+commandSandboxCommandLogs.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxCommandLogs.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxCommandLogs.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxCommandLogs.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxCommandLogs.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxCommandLogs.option('-f, --follow', texts_1.OPTION_SANDBOX_COMMAND_FOLLOW);
+commandSandboxCommandLogs.option('-l, --last', texts_1.OPTION_SANDBOX_COMMAND_LAST);
+commandSandboxCommandLogs.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxCommandLogs.argument('[command-id]', texts_1.OPTION_SANDBOX_COMMAND_ID);
+commandSandboxCommandLogs.action(async (identifier, commandId, options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = new client_1.default(baseUrl, token);
+    // Find sandbox by identifier
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    // If --last flag is used or no command-id provided, get the most recent command
+    let resolvedCommandId = commandId || '';
+    if (options.last || !commandId) {
+        const commandsResult = await client.listSandboxCommands(workspace, found.id);
+        const commands = commandsResult.commands || [];
+        if (commands.length === 0) {
+            output_1.default.exitError(texts_1.ERR_SANDBOX_NO_COMMANDS);
+        }
+        // Sort by ID descending (IDs are timestamp-based, so newest first)
+        commands.sort((a, b) => (b.id || '').localeCompare(a.id || ''));
+        resolvedCommandId = commands[0].id;
+    }
+    const logsUrl = await client.getSandboxCommandLogsUrl(workspace, found.id, resolvedCommandId);
+    try {
+        const response = await fetch(logsUrl, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/jsonl',
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (response.ok && response.body) {
+            if (options.follow) {
+                // Streaming mode - read and output as data arrives
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = '';
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (!line.trim())
+                            continue;
+                        try {
+                            const logEntry = JSON.parse(line);
+                            const content = logEntry.data ?? logEntry.message ?? '';
+                            if (content) {
+                                if (logEntry.stream === 'stderr' || logEntry.type === 'STDERR') {
+                                    process.stderr.write(content + '\n');
+                                }
+                                else {
+                                    process.stdout.write(content + '\n');
+                                }
+                            }
+                        }
+                        catch {
+                            process.stdout.write(line + '\n');
+                        }
+                    }
+                }
+                // Process remaining buffer
+                if (buffer.trim()) {
+                    try {
+                        const logEntry = JSON.parse(buffer);
+                        const content = logEntry.data ?? logEntry.message ?? '';
+                        if (content) {
+                            process.stdout.write(content + '\n');
+                        }
+                    }
+                    catch {
+                        process.stdout.write(buffer + '\n');
+                    }
+                }
+            }
+            else {
+                // Default mode - fetch all and output at once
+                const text = await response.text();
+                const lines = text.split('\n');
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const logEntry = JSON.parse(line);
+                        const content = logEntry.data ?? logEntry.message ?? '';
+                        if (content) {
+                            if (logEntry.stream === 'stderr' || logEntry.type === 'STDERR') {
+                                process.stderr.write(content + '\n');
+                            }
+                            else {
+                                process.stdout.write(content + '\n');
+                            }
+                        }
+                    }
+                    catch {
+                        process.stdout.write(line + '\n');
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        output_1.default.exitError(err);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxCommandLogs;

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

@@ -0,0 +1,44 @@
+"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 client_1 = __importDefault(require("../../../api/client"));
+const commandSandboxCommandStatus = (0, utils_1.newCommand)('status', texts_1.DESC_COMMAND_SANDBOX_COMMAND_STATUS);
+commandSandboxCommandStatus.option('--token <token>', texts_1.OPTION_REST_API_TOKEN);
+commandSandboxCommandStatus.option('--api <url>', texts_1.OPTION_REST_API_ENDPOINT);
+commandSandboxCommandStatus.option('--region <region>', texts_1.OPTION_REST_API_REGION);
+commandSandboxCommandStatus.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandSandboxCommandStatus.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandSandboxCommandStatus.argument('<identifier>', texts_1.OPTION_SANDBOX_IDENTIFIER);
+commandSandboxCommandStatus.argument('<command-id>', texts_1.OPTION_SANDBOX_COMMAND_ID);
+commandSandboxCommandStatus.action(async (identifier, commandId, options) => {
+    const token = input_1.default.restApiToken(options.token);
+    const baseUrl = input_1.default.restApiBaseUrl(options.api, options.region);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project);
+    const client = new client_1.default(baseUrl, token);
+    // Find sandbox by identifier
+    const result = await client.listSandboxes(workspace, project);
+    const sandboxes = result.sandboxes || [];
+    const found = sandboxes.find((s) => s.identifier === identifier);
+    if (!found) {
+        output_1.default.exitError(texts_1.ERR_SANDBOX_NOT_FOUND);
+    }
+    const cmd = await client.getSandboxCommand(workspace, found.id, commandId);
+    const data = [
+        ['Property', 'Value'],
+        ['Command ID', cmd.id || '-'],
+        ['Command', cmd.command || '-'],
+        ['Runtime', cmd.runtime || 'BASH'],
+        ['Status', cmd.status || '-'],
+        ['Exit Code', cmd.exit_code !== undefined ? String(cmd.exit_code) : '-'],
+    ];
+    output_1.default.table(data);
+    output_1.default.exitNormal();
+});
+exports.default = commandSandboxCommandStatus;