@relesio/cli 0.2.6

package/dist/commands/deploy.js

@@ -0,0 +1,293 @@
+import { Command } from "commander";
+import inquirer from "inquirer";
+import ora from "ora";
+import chalk from "chalk";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { RelesioAPIClient } from "../lib/api/client.js";
+import { ConfigManager } from "../lib/config/manager.js";
+import { getProjectBySlug } from "../lib/api/projects.js";
+import { listVersions } from "../lib/api/versions.js";
+import { listEnvironments, deployVersion, getEnvironmentBySlug } from "../lib/api/deployments.js";
+import { handleError } from "../lib/errors/handler.js";
+const PACKAGE_JSON = "package.json";
+/**
+ * Format a UUID string to include dashes (8-4-4-4-12 format)
+ * If already formatted, returns as-is
+ */
+function formatUUID(uuid) {
+    // Remove any existing dashes
+    const cleaned = uuid.replace(/-/g, "");
+    // If not 32 hex characters, return as-is (might already be formatted or invalid)
+    if (cleaned.length !== 32 || !/^[0-9a-f]+$/i.test(cleaned)) {
+        return uuid;
+    }
+    // Format as 8-4-4-4-12
+    return `${cleaned.slice(0, 8)}-${cleaned.slice(8, 12)}-${cleaned.slice(12, 16)}-${cleaned.slice(16, 20)}-${cleaned.slice(20)}`;
+}
+const validateSlug = (input) => {
+    if (!input || input.trim().length === 0) {
+        return "Project slug is required";
+    }
+    if (!/^[a-z0-9-]+$/.test(input)) {
+        return "Project slug must contain only lowercase letters, numbers, and hyphens";
+    }
+    return true;
+};
+function slugify(value) {
+    if (!value)
+        return undefined;
+    const slug = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return slug || undefined;
+}
+function loadPackageMetadata(baseDir) {
+    const candidates = new Set([
+        path.resolve(process.cwd(), PACKAGE_JSON),
+        path.resolve(baseDir, PACKAGE_JSON),
+        path.resolve(path.dirname(baseDir), PACKAGE_JSON)
+    ]);
+    for (const candidate of candidates) {
+        if (!fs.existsSync(candidate))
+            continue;
+        try {
+            const content = fs.readFileSync(candidate, "utf8");
+            const parsed = JSON.parse(content);
+            return parsed;
+        }
+        catch {
+            // Ignore parse errors and keep searching
+        }
+    }
+    return {};
+}
+export const deployCommand = new Command("deploy")
+    .description("Deploy a version to an environment")
+    .argument("[project-slug]", "Project slug (optional if package.json exists)")
+    .argument("[version]", "Version to deploy (e.g., 1.0.0)")
+    .option("-e, --env <environment>", "Environment slug (production, staging, etc.)")
+    .option("--latest", "Deploy the latest version")
+    .option("-y, --yes", "Skip confirmation prompts")
+    .option("--json", "Output as JSON")
+    .action(async (projectSlugArg, versionArg, options) => {
+    const spinner = ora("Preparing deployment...").start();
+    try {
+        const config = ConfigManager.load();
+        if (!config.apiToken) {
+            spinner.fail("Not authenticated. Run 'relesio auth login' first.");
+            process.exit(1);
+        }
+        const client = new RelesioAPIClient(config.apiBaseUrl, config.apiToken);
+        // Load package.json metadata
+        const packageMetadata = loadPackageMetadata(process.cwd());
+        const inferredSlug = slugify(packageMetadata.name);
+        // Determine project slug
+        let projectSlug = projectSlugArg || "";
+        if (!projectSlug &&
+            inferredSlug &&
+            validateSlug(inferredSlug) === true) {
+            projectSlug = inferredSlug;
+            spinner.info(`Using project slug from package.json: ${chalk.cyan(projectSlug)}`);
+            spinner.start("Preparing deployment...");
+        }
+        if (!projectSlug) {
+            spinner.fail("Project slug is required. Provide it as an argument or ensure package.json has a 'name' field.");
+            process.exit(1);
+        }
+        const validationResult = validateSlug(projectSlug);
+        if (validationResult !== true) {
+            spinner.fail(String(validationResult));
+            process.exit(1);
+        }
+        // Get project
+        spinner.text = "Looking up project...";
+        const project = await getProjectBySlug(client, projectSlug);
+        if (!project) {
+            spinner.fail(`Project '${projectSlug}' not found`);
+            // If DEBUG is enabled, show available projects to help diagnose the issue
+            if (process.env.DEBUG) {
+                const { listProjects } = await import("../lib/api/projects.js");
+                const { projects } = await listProjects(client);
+                console.error(chalk.dim(`\n[DEBUG] Available projects in this organization (${projects.length} total):`));
+                if (projects.length > 0) {
+                    projects.forEach((p) => {
+                        console.error(chalk.dim(`  - ${p.slug} (name: "${p.name}", id: ${p.id})`));
+                    });
+                }
+                else {
+                    console.error(chalk.dim(`  (no projects found)`));
+                }
+                console.error(chalk.dim(`[DEBUG] Looking for: "${projectSlug}"\n`));
+            }
+            console.log(chalk.yellow(`\nThe project '${projectSlug}' does not exist yet.\n\n` +
+                `Possible reasons:\n` +
+                `  1. You haven't uploaded any versions yet\n` +
+                `  2. The project slug might be incorrect\n` +
+                `  3. The project exists in a different organization\n\n` +
+                `Next steps:\n` +
+                `  • Upload a version first: ${chalk.cyan(`relesio upload`)}\n` +
+                `  • List available projects: ${chalk.cyan(`relesio projects list`)}\n` +
+                `  • Or specify the correct project slug: ${chalk.cyan(`relesio deploy <project-slug> --env stage`)}\n`));
+            process.exit(1);
+        }
+        spinner.text = "Loading environments and versions...";
+        // Get environments
+        const { environments } = await listEnvironments(client, project.id);
+        if (environments.length === 0) {
+            spinner.fail("No environments found for this project");
+            process.exit(1);
+        }
+        // Get versions
+        const { versions } = await listVersions(client, project.id);
+        const completedVersions = versions.filter((v) => v.status === "completed");
+        if (completedVersions.length === 0) {
+            spinner.fail("No completed versions available to deploy");
+            process.exit(1);
+        }
+        spinner.stop();
+        // Select environment (if not provided)
+        let selectedEnv = options.env
+            ? await getEnvironmentBySlug(client, project.id, options.env)
+            : null;
+        if (!selectedEnv) {
+            const { environmentSlug } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "environmentSlug",
+                    message: "Select environment:",
+                    choices: environments.map((env) => ({
+                        name: `${env.name} (${env.slug})${env.currentDeployment
+                            ? ` - current: ${env.currentDeployment
+                                .semanticVersion ||
+                                env.currentDeployment.versionId}`
+                            : ""}`,
+                        value: env.slug
+                    }))
+                }
+            ]);
+            selectedEnv = await getEnvironmentBySlug(client, project.id, environmentSlug);
+        }
+        if (!selectedEnv) {
+            console.error(chalk.red("Environment not found"));
+            process.exit(1);
+        }
+        // Select version (if not provided)
+        let selectedVersionId;
+        let selectedVersionStr;
+        if (options.latest) {
+            // Use the most recent version
+            const latestVersion = completedVersions[0];
+            selectedVersionId = latestVersion.id;
+            selectedVersionStr =
+                latestVersion.semanticVersion || latestVersion.id;
+        }
+        else if (versionArg) {
+            // Find version by string (match against semanticVersion)
+            const version = completedVersions.find((v) => v.semanticVersion === versionArg);
+            if (!version) {
+                console.error(chalk.red(`Version '${versionArg}' not found or not completed`));
+                process.exit(1);
+            }
+            selectedVersionId = version.id;
+            selectedVersionStr = version.semanticVersion || version.id;
+        }
+        else if (packageMetadata.version) {
+            // Try to use version from package.json
+            const version = completedVersions.find((v) => v.semanticVersion === packageMetadata.version);
+            if (version) {
+                selectedVersionId = version.id;
+                selectedVersionStr =
+                    version.semanticVersion || version.id;
+                console.log(chalk.dim(`Using version from package.json: ${chalk.cyan(selectedVersionStr)}`));
+            }
+            else {
+                // Version from package.json not found, fall back to interactive
+                console.log(chalk.yellow(`Version '${packageMetadata.version}' from package.json not found or not completed. Please select a version:`));
+                const { versionId } = await inquirer.prompt([
+                    {
+                        type: "list",
+                        name: "versionId",
+                        message: "Select version to deploy:",
+                        choices: completedVersions.map((v) => ({
+                            name: `${v.semanticVersion || v.id} - ${v.gitSha?.substring(0, 7) || "no git"} - ${new Date(v.uploadDate).toLocaleDateString()}`,
+                            value: v.id
+                        }))
+                    }
+                ]);
+                selectedVersionId = versionId;
+                const selectedVersion = completedVersions.find((v) => v.id === versionId);
+                if (!selectedVersion)
+                    throw new Error("Version not found");
+                selectedVersionStr =
+                    selectedVersion.semanticVersion ||
+                        selectedVersion.id;
+            }
+        }
+        else {
+            // Interactive selection
+            const { versionId } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "versionId",
+                    message: "Select version to deploy:",
+                    choices: completedVersions.map((v) => ({
+                        name: `${v.semanticVersion || v.id} - ${v.gitSha?.substring(0, 7) || "no git"} - ${new Date(v.uploadDate).toLocaleDateString()}`,
+                        value: v.id
+                    }))
+                }
+            ]);
+            selectedVersionId = versionId;
+            const version = completedVersions.find((v) => v.id === versionId);
+            if (!version)
+                throw new Error("Version not found");
+            selectedVersionStr = version.semanticVersion || version.id;
+        }
+        // Confirmation
+        if (!options.yes) {
+            console.log(`\n${chalk.bold("Deployment Details:")}\n` +
+                `  Project:     ${chalk.cyan(project.name)} (${project.slug})\n` +
+                `  Environment: ${chalk.cyan(selectedEnv.name)} (${selectedEnv.slug})${selectedEnv.isProduction ? chalk.red(" [PRODUCTION]") : ""}\n` +
+                `  Version:     ${chalk.cyan(selectedVersionStr)}\n`);
+            if (selectedEnv.currentDeployment) {
+                console.log(`  Current:     ${chalk.yellow(selectedEnv.currentDeployment.semanticVersion ||
+                    selectedEnv.currentDeployment.versionId)}\n`);
+            }
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Deploy version ${selectedVersionStr} to ${selectedEnv.name}?`,
+                    default: false
+                }
+            ]);
+            if (!confirm) {
+                console.log(chalk.yellow("\nDeployment cancelled"));
+                return;
+            }
+        }
+        // Deploy
+        const deploySpinner = ora("Deploying...").start();
+        // Format environment ID with dashes if needed (API expects UUID format)
+        const formattedEnvId = formatUUID(selectedEnv.id);
+        const result = await deployVersion(client, project.id, formattedEnvId, { versionId: selectedVersionId, projectId: project.id });
+        deploySpinner.succeed(`Deployed version ${chalk.green(selectedVersionStr)} to ${chalk.green(selectedEnv.name)}`);
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`\n${chalk.bold("Deployment successful!")}\n` +
+                `  URL: ${chalk.cyan(result.url)}\n` +
+                `  Deployment ID: ${result.deployment.id}\n`);
+            if (selectedEnv.isProduction) {
+                console.log(chalk.yellow("⚠️  This is a production deployment. Monitor closely!\n"));
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail("Deployment failed");
+        handleError(error);
+    }
+});

package/dist/commands/organizations/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const organizationsCommand: Command;

package/dist/commands/organizations/index.js

@@ -0,0 +1,8 @@
+import { Command } from "commander";
+import { listOrganizationsCommand } from "./list.js";
+import { setOrganizationCommand } from "./set.js";
+export const organizationsCommand = new Command("organizations")
+    .alias("orgs")
+    .description("Manage organizations")
+    .addCommand(listOrganizationsCommand)
+    .addCommand(setOrganizationCommand);

package/dist/commands/organizations/list.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const listOrganizationsCommand: Command;

package/dist/commands/organizations/list.js

@@ -0,0 +1,54 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import Table from "cli-table3";
+import { ConfigManager } from "../../lib/config/manager.js";
+import { RelesioAPIClient } from "../../lib/api/client.js";
+import { handleError } from "../../lib/errors/handler.js";
+export const listOrganizationsCommand = new Command("list")
+    .description("List your organizations")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    const spinner = ora("Fetching organizations...").start();
+    try {
+        const config = ConfigManager.load();
+        if (!config.apiToken) {
+            spinner.fail("Not authenticated. Run 'relesio auth login' first.");
+            process.exit(1);
+        }
+        const client = new RelesioAPIClient(config.apiBaseUrl, config.apiToken);
+        const response = await client.get("/v1/users/me/organizations", { raw: true });
+        spinner.succeed("Organizations retrieved");
+        const { organizations: orgs, currentOrganizationId } = response.data;
+        const activeOrgId = currentOrganizationId || config.activeOrganizationId;
+        if (options.json) {
+            console.log(JSON.stringify(orgs, null, 2));
+            return;
+        }
+        if (orgs.length === 0) {
+            console.log(chalk.yellow("No organizations found"));
+            return;
+        }
+        const table = new Table({
+            head: ["", "Name", "Slug", "Role"],
+            colWidths: [3, 30, 25, 20]
+        });
+        for (const org of orgs) {
+            const isActive = org.id === activeOrgId;
+            table.push([
+                isActive ? chalk.green("✓") : "",
+                org.name,
+                org.slug,
+                org.role ?? "-"
+            ]);
+        }
+        console.log(table.toString());
+        if (config.activeOrganizationId) {
+            console.log(chalk.dim("\n✓ marks your active organization"));
+        }
+    }
+    catch (error) {
+        spinner.fail("Failed to fetch organizations");
+        handleError(error);
+    }
+});

package/dist/commands/organizations/set.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const setOrganizationCommand: Command;

package/dist/commands/organizations/set.js

@@ -0,0 +1,34 @@
+import { Command } from "commander";
+import ora from "ora";
+import { ConfigManager } from "../../lib/config/manager.js";
+import { RelesioAPIClient } from "../../lib/api/client.js";
+import { handleError } from "../../lib/errors/handler.js";
+export const setOrganizationCommand = new Command("set")
+    .description("Set your active organization")
+    .argument("<org-id>", "Organization ID or slug")
+    .action(async (orgIdOrSlug) => {
+    const spinner = ora("Switching organization...").start();
+    try {
+        const config = ConfigManager.load();
+        if (!config.apiToken) {
+            spinner.fail("Not authenticated. Run 'relesio auth login' first.");
+            process.exit(1);
+        }
+        const client = new RelesioAPIClient(config.apiBaseUrl, config.apiToken);
+        // Call API to switch active org (updates session)
+        const response = await client.post("/v1/users/me/organization", { organizationId: orgIdOrSlug }, { raw: true });
+        // Update local config
+        config.activeOrganizationId = response.data.organizationId;
+        config.activeOrganizationName = response.data.organizationName;
+        config.activeOrganizationSlug = response.data.organizationSlug;
+        // Legacy fields
+        config.currentOrgId = response.data.organizationId;
+        config.currentOrgName = response.data.organizationName;
+        ConfigManager.save(config);
+        spinner.succeed(`Active organization set to: ${response.data.organizationName} (${response.data.organizationSlug})`);
+    }
+    catch (error) {
+        spinner.fail("Failed to switch organization");
+        handleError(error);
+    }
+});

package/dist/commands/projects/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const projectsCommand: Command;

package/dist/commands/projects/index.js

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+import { listProjectsCommand } from "./list.js";
+export const projectsCommand = new Command("projects")
+    .alias("project")
+    .description("Manage projects")
+    .addCommand(listProjectsCommand);

package/dist/commands/projects/list.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const listProjectsCommand: Command;

package/dist/commands/projects/list.js

@@ -0,0 +1,49 @@
+import { Command } from "commander";
+import ora from "ora";
+import { RelesioAPIClient } from "../../lib/api/client.js";
+import { ConfigManager } from "../../lib/config/manager.js";
+import { listProjects } from "../../lib/api/projects.js";
+import { formatTable } from "../../lib/output/table.js";
+import { handleError } from "../../lib/errors/handler.js";
+export const listProjectsCommand = new Command("list")
+    .description("List all projects in your organization")
+    .option("--json", "Output as JSON")
+    .action(async (options, command) => {
+    const spinner = ora("Loading projects...").start();
+    try {
+        const config = ConfigManager.load();
+        if (!config.apiToken) {
+            spinner.fail("Not authenticated. Run 'relesio auth login' first.");
+            process.exit(1);
+        }
+        // Get org context from --org flag or config
+        const orgId = command.parent?.opts().org || config.activeOrganizationId;
+        if (!orgId) {
+            spinner.fail("No organization context. Use --org flag, set RELESIO_ORG_ID, or run 'relesio organizations set <org-id>'");
+            process.exit(1);
+        }
+        const client = new RelesioAPIClient(config.apiBaseUrl, config.apiToken);
+        // Note: API client automatically adds x-organization-id header based on orgId
+        const { projects, count } = await listProjects(client);
+        spinner.stop();
+        if (options.json) {
+            console.log(JSON.stringify({ projects, count }, null, 2));
+            return;
+        }
+        if (projects.length === 0) {
+            console.log("\n✨ No projects yet. Create one with:");
+            console.log("   relesio projects create");
+            return;
+        }
+        console.log(`\n📦 Projects (${count}):\n`);
+        console.log(formatTable(["Name", "Slug", "Created"], projects.map((p) => [
+            p.name,
+            p.slug,
+            new Date(p.createdAt).toLocaleDateString()
+        ])));
+    }
+    catch (error) {
+        spinner.fail("Failed to list projects");
+        handleError(error);
+    }
+});

package/dist/commands/rollback.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const rollbackCommand: Command;

package/dist/commands/rollback.js

@@ -0,0 +1,119 @@
+import { Command } from "commander";
+import inquirer from "inquirer";
+import ora from "ora";
+import chalk from "chalk";
+import { RelesioAPIClient } from "../lib/api/client.js";
+import { ConfigManager } from "../lib/config/manager.js";
+import { getProjectBySlug } from "../lib/api/projects.js";
+import { listEnvironments, rollback, getEnvironmentBySlug, getDeploymentHistory } from "../lib/api/deployments.js";
+import { handleError } from "../lib/errors/handler.js";
+export const rollbackCommand = new Command("rollback")
+    .description("Rollback to the previous version in an environment")
+    .argument("<project-slug>", "Project slug")
+    .option("-e, --env <environment>", "Environment slug (production, staging, etc.)")
+    .option("-y, --yes", "Skip confirmation prompts")
+    .option("--json", "Output as JSON")
+    .action(async (projectSlug, options) => {
+    const spinner = ora("Preparing rollback...").start();
+    try {
+        const config = ConfigManager.load();
+        if (!config.apiToken) {
+            spinner.fail("Not authenticated. Run 'relesio auth login' first.");
+            process.exit(1);
+        }
+        const client = new RelesioAPIClient(config.apiBaseUrl, config.apiToken);
+        // Get project
+        const project = await getProjectBySlug(client, projectSlug);
+        if (!project) {
+            spinner.fail(`Project '${projectSlug}' not found`);
+            process.exit(1);
+        }
+        spinner.text = "Loading environments...";
+        // Get environments
+        const { environments } = await listEnvironments(client, project.id);
+        const envsWithDeployments = environments.filter((env) => env.currentDeployment);
+        if (envsWithDeployments.length === 0) {
+            spinner.fail("No environments with deployments found");
+            process.exit(1);
+        }
+        spinner.stop();
+        // Select environment (if not provided)
+        let selectedEnv = options.env
+            ? await getEnvironmentBySlug(client, project.id, options.env)
+            : null;
+        if (!selectedEnv) {
+            const { environmentSlug } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "environmentSlug",
+                    message: "Select environment to rollback:",
+                    choices: envsWithDeployments.map((env) => ({
+                        name: `${env.name} (${env.slug}) - current: ${env.currentDeployment?.semanticVersion ||
+                            env.currentDeployment?.version ||
+                            env.currentDeployment?.versionId}`,
+                        value: env.slug
+                    }))
+                }
+            ]);
+            selectedEnv = await getEnvironmentBySlug(client, project.id, environmentSlug);
+        }
+        if (!selectedEnv || !selectedEnv.currentDeployment) {
+            console.error(chalk.red("Environment not found or has no deployments"));
+            process.exit(1);
+        }
+        // Get deployment history
+        const historySpinner = ora("Loading deployment history...").start();
+        const { deployments } = await getDeploymentHistory(client, project.id, selectedEnv.id, 5);
+        historySpinner.stop();
+        if (deployments.length < 2) {
+            console.error(chalk.red("Cannot rollback: No previous version found in deployment history"));
+            process.exit(1);
+        }
+        const currentVersion = deployments[0].semanticVersion || deployments[0].versionId;
+        const previousVersion = deployments[1].semanticVersion || deployments[1].versionId;
+        // Confirmation
+        if (!options.yes) {
+            console.log(`\n${chalk.bold("Rollback Details:")}\n` +
+                `  Project:      ${chalk.cyan(project.name)} (${project.slug})\n` +
+                `  Environment:  ${chalk.cyan(selectedEnv.name)} (${selectedEnv.slug})${selectedEnv.isProduction ? chalk.red(" [PRODUCTION]") : ""}\n` +
+                `  Current:      ${chalk.yellow(currentVersion)}\n` +
+                `  Rollback to:  ${chalk.green(previousVersion)}\n`);
+            console.log(chalk.bold("\nRecent deployments:"));
+            deployments.slice(0, 3).forEach((d, i) => {
+                console.log(`  ${i === 0 ? "→" : " "} ${d.semanticVersion || d.versionId} - ${d.deploymentType} by ${d.deployedBy} (${new Date(d.deployedAt).toLocaleString()})`);
+            });
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Rollback ${selectedEnv.name} from ${currentVersion} to ${previousVersion}?`,
+                    default: false
+                }
+            ]);
+            if (!confirm) {
+                console.log(chalk.yellow("\nRollback cancelled"));
+                return;
+            }
+        }
+        // Rollback
+        const rollbackSpinner = ora("Rolling back...").start();
+        const result = await rollback(client, project.id, selectedEnv.id);
+        rollbackSpinner.succeed(`Rolled back to version ${chalk.green(result.version)}`);
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`\n${chalk.bold("Rollback successful!")}\n` +
+                `  Previous version:  ${chalk.red(result.rolledBackFrom)}\n` +
+                `  Current version:   ${chalk.green(result.version)}\n` +
+                `  Propagation:       <30 seconds\n`);
+            if (selectedEnv.isProduction) {
+                console.log(chalk.yellow("⚠️  Production rolled back. Verify the application is working correctly.\n"));
+            }
+        }
+    }
+    catch (error) {
+        spinner.fail("Rollback failed");
+        handleError(error);
+    }
+});

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const statusCommand: Command;

package/dist/commands/status.js

@@ -0,0 +1,59 @@
+import { Command } from "commander";
+import ora from "ora";
+import chalk from "chalk";
+import { RelesioAPIClient } from "../lib/api/client.js";
+import { ConfigManager } from "../lib/config/manager.js";
+import { getProjectBySlug } from "../lib/api/projects.js";
+import { getDeploymentStatus } from "../lib/api/deployments.js";
+import { formatTable } from "../lib/output/table.js";
+import { handleError } from "../lib/errors/handler.js";
+export const statusCommand = new Command("status")
+    .description("Show deployment status across all environments")
+    .argument("<project-slug>", "Project slug")
+    .option("--json", "Output as JSON")
+    .action(async (projectSlug, options) => {
+    const spinner = ora("Loading deployment status...").start();
+    try {
+        const config = ConfigManager.load();
+        if (!config.apiToken) {
+            spinner.fail("Not authenticated. Run 'relesio auth login' first.");
+            process.exit(1);
+        }
+        const client = new RelesioAPIClient(config.apiBaseUrl, config.apiToken);
+        // Get project
+        const project = await getProjectBySlug(client, projectSlug);
+        if (!project) {
+            spinner.fail(`Project '${projectSlug}' not found`);
+            process.exit(1);
+        }
+        const result = await getDeploymentStatus(client, project.id);
+        spinner.stop();
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\n📊 Deployment Status for ${chalk.bold(project.name)}\n`);
+        if (result.status.length === 0) {
+            console.log("  No environments configured\n");
+            return;
+        }
+        console.log(formatTable(["Environment", "Type", "Version", "Deployed"], result.status.map((s) => [
+            s.environment.name,
+            s.environment.isProduction
+                ? chalk.red("production")
+                : chalk.gray("staging"),
+            s.currentDeployment
+                ? chalk.green(s.currentDeployment.semanticVersion ||
+                    s.currentDeployment.versionId)
+                : chalk.gray("-"),
+            s.currentDeployment
+                ? new Date(s.currentDeployment.deployedAt).toLocaleString()
+                : "-"
+        ])));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail("Failed to get deployment status");
+        handleError(error);
+    }
+});

package/dist/commands/team/get.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const getCommand: Command;