@relesio/cli 0.2.6

package/dist/commands/team/get.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 { TeamsAPI } from "../../lib/api/teams.js";
+import { renderTeamDetails } from "../../lib/output/table.js";
+import { outputJSON, shouldOutputJSON } from "../../lib/output/formatter.js";
+import { AuthenticationError } from "../../lib/errors/types.js";
+export const getCommand = new Command("get")
+    .description("Get details of a specific team")
+    .argument("<teamId>", "Team ID")
+    .action(async (teamId) => {
+    const config = ConfigManager.load();
+    if (!config.apiToken) {
+        throw new AuthenticationError();
+    }
+    const spinner = ora("Fetching team details...").start();
+    try {
+        const client = new RelesioAPIClient(config.apiBaseUrl, config.apiToken);
+        const teamsAPI = new TeamsAPI(client);
+        const team = await teamsAPI.get(teamId);
+        spinner.stop();
+        if (shouldOutputJSON()) {
+            outputJSON(team);
+        }
+        else {
+            renderTeamDetails(team);
+        }
+    }
+    catch (error) {
+        spinner.fail("Failed to fetch team details");
+        throw error;
+    }
+});

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

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

package/dist/commands/team/index.js

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+import { listCommand } from "./list.js";
+import { getCommand } from "./get.js";
+export const teamCommand = new Command("team")
+    .description("Manage teams")
+    .addCommand(listCommand)
+    .addCommand(getCommand);

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

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

package/dist/commands/team/list.js

@@ -0,0 +1,46 @@
+import { Command } from "commander";
+import ora from "ora";
+import { ConfigManager } from "../../lib/config/manager.js";
+import { RelesioAPIClient } from "../../lib/api/client.js";
+import { TeamsAPI } from "../../lib/api/teams.js";
+import { renderTeamsTable } from "../../lib/output/table.js";
+import { outputJSON, shouldOutputJSON } from "../../lib/output/formatter.js";
+import { AuthenticationError } from "../../lib/errors/types.js";
+export const listCommand = new Command("list")
+    .alias("ls")
+    .description("List all teams")
+    .option("--limit <limit>", "Number of teams to return (default: 50)", "50")
+    .option("--offset <offset>", "Offset for pagination (default: 0)", "0")
+    .action(async (options, command) => {
+    const config = ConfigManager.load();
+    if (!config.apiToken) {
+        throw new AuthenticationError();
+    }
+    // Get org context from --org flag or config
+    const orgId = command.parent?.opts().org || config.activeOrganizationId;
+    if (!orgId) {
+        const spinner = ora();
+        spinner.fail("No organization context. Use --org flag, set RELESIO_ORG_ID, or run 'relesio organizations set <org-id>'");
+        process.exit(1);
+    }
+    const spinner = ora("Fetching teams...").start();
+    try {
+        const client = new RelesioAPIClient(config.apiBaseUrl, config.apiToken);
+        const teamsAPI = new TeamsAPI(client);
+        const response = await teamsAPI.list({
+            limit: parseInt(options.limit, 10),
+            offset: parseInt(options.offset, 10)
+        });
+        spinner.stop();
+        if (shouldOutputJSON()) {
+            outputJSON(response);
+        }
+        else {
+            renderTeamsTable(response.data);
+        }
+    }
+    catch (error) {
+        spinner.fail("Failed to fetch teams");
+        throw error;
+    }
+});

package/dist/commands/upload.d.ts

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

package/dist/commands/upload.js

@@ -0,0 +1,365 @@
+import { Command } from "commander";
+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, createProject } from "../lib/api/projects.js";
+import { createVersion, completeVersion, gitMetadataToApiFormat } from "../lib/api/versions.js";
+import { collectGitMetadata, formatGitMetadata, validateGitState } from "../lib/git/metadata.js";
+import { scanDirectory, formatFileSize, getTotalSize } from "../lib/files/scanner.js";
+import { handleError } from "../lib/errors/handler.js";
+const PACKAGE_JSON = "package.json";
+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 {};
+}
+function buildDependencies(pkg) {
+    if (!pkg)
+        return undefined;
+    const deps = pkg.dependencies ?? {};
+    const devDeps = pkg.devDependencies ?? {};
+    const toList = (obj, type) => Object.entries(obj).map(([name, version]) => ({ name, version, type }));
+    const combined = [
+        ...toList(deps, "dependency"),
+        ...toList(devDeps, "devDependency")
+    ];
+    return combined.length > 0 ? combined : undefined;
+}
+export const uploadCommand = new Command("upload")
+    .description("Upload a new version to a project")
+    .argument("[directory]", "Directory containing files to upload (default: dist)", "dist")
+    .option("-p, --project <slug>", "Project slug")
+    .option("-v, --version <version>", "Version string (e.g., 1.0.0)")
+    .option("--require-clean", "Require clean git working directory")
+    .option("-y, --yes", "Skip confirmation prompts")
+    .option("--json", "Output as JSON")
+    .action(async (directory, options) => {
+    const spinner = ora("Preparing upload...").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 resolvedDirectory = path.resolve(directory || "dist");
+        const packageMetadata = loadPackageMetadata(resolvedDirectory);
+        const inferredSlug = slugify(packageMetadata.name);
+        // Step 1: Collect git metadata
+        spinner.text = "Collecting git metadata...";
+        const gitMetadata = await collectGitMetadata();
+        try {
+            validateGitState(gitMetadata, options.requireClean);
+        }
+        catch (error) {
+            spinner.fail(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+        // Step 2: Scan directory for files
+        spinner.text = "Scanning directory...";
+        let files;
+        try {
+            files = await scanDirectory(resolvedDirectory);
+        }
+        catch (error) {
+            spinner.fail(`Failed to scan directory '${resolvedDirectory}': ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+        if (files.length === 0) {
+            spinner.fail("No files found in directory");
+            process.exit(1);
+        }
+        const totalSize = getTotalSize(files);
+        spinner.stop();
+        // Step 3: Get or prompt for project
+        let projectSlug = options.project || "";
+        if (!projectSlug &&
+            inferredSlug &&
+            validateSlug(inferredSlug) === true) {
+            projectSlug = inferredSlug;
+            console.log(chalk.dim(`Using project slug from package.json: ${chalk.cyan(projectSlug)}`));
+        }
+        if (!projectSlug) {
+            projectSlug =
+                slugify(path.basename(resolvedDirectory)) ||
+                    slugify(path.basename(process.cwd())) ||
+                    "project";
+            console.log(chalk.dim(`Using inferred project slug: ${chalk.cyan(projectSlug)}`));
+        }
+        const validationResult = validateSlug(projectSlug);
+        if (validationResult !== true) {
+            spinner.fail(String(validationResult));
+            process.exit(1);
+        }
+        // Get or create project
+        spinner.start("Loading project...");
+        let project = await getProjectBySlug(client, projectSlug);
+        if (!project) {
+            spinner.stop();
+            spinner.start("Project not found. Creating...");
+            const createResult = await createProject(client, {
+                name: projectSlug,
+                slug: projectSlug
+            });
+            project = createResult.project;
+            spinner.succeed(`Created project '${project.name}'`);
+        }
+        else {
+            spinner.stop();
+        }
+        // Step 4: Determine version (non-interactive)
+        const semverPattern = /^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?(?:\+[a-zA-Z0-9.-]+)?$/;
+        let versionString = options.version ||
+            packageMetadata.version ||
+            gitMetadata.tag ||
+            "0.0.1";
+        const semanticVersion = packageMetadata.version;
+        if (!semverPattern.test(versionString)) {
+            console.log(chalk.yellow(`Version '${versionString}' is not valid semver. Falling back to 0.0.1.`));
+            versionString = "0.0.1";
+        }
+        if (!options.version && !packageMetadata.version) {
+            console.log(chalk.dim(`No package.json version found. Using ${chalk.cyan(versionString)}`));
+        }
+        // Step 5: Display upload summary (auto-confirm)
+        console.log(`\n${chalk.bold("Upload Summary:")}\n` +
+            `  Project:     ${chalk.cyan(project.name)} (${project.slug})\n` +
+            `  Version:     ${chalk.cyan(versionString)}\n` +
+            `  Files:       ${chalk.cyan(files.length.toString())}\n` +
+            `  Total Size:  ${chalk.cyan(formatFileSize(totalSize))}\n`);
+        if (gitMetadata.sha) {
+            console.log(chalk.bold("\nGit Metadata:"));
+            console.log(formatGitMetadata(gitMetadata));
+        }
+        console.log(chalk.dim("\nAuto-confirming upload (non-interactive). Proceeding...\n"));
+        // Step 6: Create version and get presigned URLs
+        spinner.start("Initiating upload...");
+        const dependencyList = buildDependencies(packageMetadata);
+        const metadata = {};
+        if (packageMetadata.name)
+            metadata.packageName = packageMetadata.name;
+        if (packageMetadata.version)
+            metadata.packageVersion = packageMetadata.version;
+        if (packageMetadata.dependencies)
+            metadata.packageDependencies = packageMetadata.dependencies;
+        if (packageMetadata.devDependencies)
+            metadata.packageDevDependencies =
+                packageMetadata.devDependencies;
+        if (dependencyList)
+            metadata.dependencies = dependencyList;
+        if (gitMetadata.branch)
+            metadata.gitBranch = gitMetadata.branch;
+        if (gitMetadata.remoteUrl)
+            metadata.gitRemote = gitMetadata.remoteUrl;
+        metadata.gitDirty = gitMetadata.isDirty;
+        const createVersionResponse = await createVersion(client, project.id, {
+            version: versionString,
+            packageName: packageMetadata.name,
+            semanticVersion,
+            fileCount: files.length,
+            totalSizeBytes: totalSize,
+            files: files.map((f) => ({
+                path: f.path,
+                contentType: f.contentType,
+                size: f.size,
+                checksum: f.checksum
+            })),
+            dependencies: dependencyList,
+            metadata: Object.keys(metadata).length > 0
+                ? Object.fromEntries(Object.entries(metadata).filter(([, value]) => value !== undefined))
+                : undefined,
+            ...gitMetadataToApiFormat(gitMetadata)
+        });
+        spinner.succeed(`Version ${versionString} created (${createVersionResponse.versionId})`);
+        // Handle duplicate version (content-addressed deduplication)
+        if (createVersionResponse.stats?.alreadyExists) {
+            console.log(chalk.green("\n✓ Version already exists (identical content)"));
+            console.log(chalk.dim(`  Files: ${createVersionResponse.stats.existingFileCount}`));
+            console.log(chalk.dim(`  Preview URL: ${chalk.cyan(createVersionResponse.previewUrl)}`));
+            console.log(chalk.dim("\nSkipping upload (no changes needed)\n"));
+            return; // Exit early - version complete
+        }
+        // Display copy stats if incremental upload used (Phase 2)
+        if (createVersionResponse.stats &&
+            createVersionResponse.stats.copied > 0) {
+            console.log(chalk.dim(`  Server copied: ${createVersionResponse.stats.copied} unchanged files ` +
+                `(saved ${formatFileSize(createVersionResponse.stats.savedBytes)})`));
+        }
+        // Step 7: Upload files to R2 via presigned URLs (parallel batching)
+        const uploadSpinner = ora("Uploading files...").start();
+        const CONCURRENT_UPLOADS = 10; // Parallel upload limit
+        const uploadUrls = createVersionResponse.uploadUrls;
+        if (uploadUrls.length === 0) {
+            uploadSpinner.info("No files to upload (all copied server-side)");
+        }
+        else {
+            let uploadedCount = 0;
+            // Upload in batches for better performance (prevents 180s timeout)
+            for (let i = 0; i < uploadUrls.length; i += CONCURRENT_UPLOADS) {
+                const batch = uploadUrls.slice(i, i + CONCURRENT_UPLOADS);
+                const uploadPromises = batch.map(async (uploadUrl) => {
+                    // Find corresponding file
+                    const file = files.find((f) => f.path === uploadUrl.filePath);
+                    if (!file) {
+                        throw new Error(`File not found in manifest: ${uploadUrl.filePath}`);
+                    }
+                    try {
+                        // Read file
+                        const fileBuffer = fs.readFileSync(file.absolutePath);
+                        // Convert hex checksum to base64 for AWS ChecksumSHA256 header
+                        const _checksumBase64 = Buffer.from(file.checksum, "hex").toString("base64");
+                        // Upload file (either to presigned R2 URL or authenticated API endpoint)
+                        // NOTE: If using presigned URLs, cannot send x-amz-meta-* headers (signature mismatch)
+                        // Metadata will be set by worker binding after upload confirmation
+                        const headers = {
+                            "Content-Type": file.contentType
+                            // Note: Content-Length is auto-added by fetch
+                        };
+                        // Add auth header if uploading to API endpoint (not presigned R2 URL)
+                        if (!uploadUrl.uploadUrl.includes("r2.cloudflarestorage.com")) {
+                            headers.Authorization = `Bearer ${config.apiToken}`;
+                        }
+                        const response = await fetch(uploadUrl.uploadUrl, {
+                            method: "PUT",
+                            body: fileBuffer,
+                            headers
+                        });
+                        if (!response.ok) {
+                            // Get response body for detailed error info
+                            const responseText = await response.text();
+                            if (process.env.DEBUG) {
+                                console.error(`\n[DEBUG] Upload failed for ${file.path}`);
+                                console.error(`  Status: ${response.status} ${response.statusText}`);
+                                console.error(`  Response: ${responseText}`);
+                                console.error(`  Headers sent: ${JSON.stringify({
+                                    "Content-Type": file.contentType,
+                                    "Content-Length": file.size.toString(),
+                                    "x-amz-checksum-sha256": Buffer.from(file.checksum, "hex").toString("base64")
+                                }, null, 2)}`);
+                            }
+                            // Map R2/presigned URL errors to user-friendly messages
+                            const errorMessages = {
+                                403: "Upload expired (presigned URL timeout after 180s)",
+                                400: "Checksum mismatch (file may be corrupted)",
+                                413: "File too large for upload"
+                            };
+                            const errorMsg = errorMessages[response.status] ||
+                                `${response.status} ${response.statusText}`;
+                            throw new Error(`Upload failed for ${file.path}: ${errorMsg}${responseText ? ` - ${responseText}` : ""}`);
+                        }
+                        return uploadUrl.filePath;
+                    }
+                    catch (error) {
+                        throw new Error(`Failed to upload ${file.path}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                });
+                // Wait for batch to complete (fail fast on any error)
+                const results = await Promise.allSettled(uploadPromises);
+                const failed = results.find((r) => r.status === "rejected");
+                if (failed && failed.status === "rejected") {
+                    uploadSpinner.fail("Upload failed");
+                    throw failed.reason;
+                }
+                uploadedCount += batch.length;
+                uploadSpinner.text = `Uploading (${uploadedCount}/${uploadUrls.length})`;
+            }
+            // Display final upload summary with copy stats (Phase 2)
+            const totalFiles = files.length;
+            const copied = createVersionResponse.copiedFiles?.length || 0;
+            if (copied > 0) {
+                uploadSpinner.succeed(`Uploaded ${totalFiles} files (${uploadedCount} uploaded, ${copied} copied server-side)`);
+            }
+            else {
+                uploadSpinner.succeed(`Uploaded ${uploadedCount} files`);
+            }
+        }
+        // Step 8: Complete the version
+        const completeSpinner = ora("Finalizing version...").start();
+        const completeResponse = await completeVersion(client, project.id, createVersionResponse.versionId, {
+            assets: createVersionResponse.uploadUrls.map((u) => {
+                const file = files.find((f) => f.path === u.filePath);
+                if (!file)
+                    throw new Error(`File not found for path: ${u.filePath}`);
+                return {
+                    filePath: file.path,
+                    sizeBytes: file.size,
+                    contentType: file.contentType,
+                    r2Key: u.r2Key,
+                    checksum: file.checksum
+                };
+            }),
+            // Include copied files list for server validation (Phase 2)
+            copiedAssets: createVersionResponse.copiedFiles
+        });
+        completeSpinner.succeed(`Version ${chalk.green(versionString)} upload complete!`);
+        // Step 9: Display results
+        if (options.json) {
+            console.log(JSON.stringify({
+                project: {
+                    id: project.id,
+                    name: project.name,
+                    slug: project.slug
+                },
+                version: {
+                    id: completeResponse.versionId,
+                    version: versionString,
+                    fileCount: completeResponse.fileCount,
+                    totalSize: completeResponse.totalSize
+                },
+                previewUrl: completeResponse.previewUrl,
+                gitMetadata
+            }, null, 2));
+        }
+        else {
+            console.log(`\n${chalk.bold("Upload Successful!")}\n` +
+                `  Version:      ${chalk.green(versionString)}\n` +
+                `  Files:        ${chalk.green(completeResponse.fileCount.toString())}\n` +
+                `  Total Size:   ${chalk.green(formatFileSize(completeResponse.totalSize))}\n` +
+                `  Preview URL:  ${chalk.cyan(completeResponse.previewUrl)}\n`);
+            console.log(chalk.dim(`\nNext steps:\n` +
+                `  1. Test your version at the preview URL\n` +
+                `  2. Deploy to an environment: ${chalk.cyan(`relesio deploy ${project.slug} ${versionString} --env staging`)}\n`));
+        }
+    }
+    catch (error) {
+        spinner.fail("Upload failed");
+        handleError(error);
+    }
+});

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

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

package/dist/commands/versions/index.js

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+import { listVersionsCommand } from "./list.js";
+export const versionsCommand = new Command("versions")
+    .alias("version")
+    .description("Manage versions")
+    .addCommand(listVersionsCommand);

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

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

package/dist/commands/versions/list.js

@@ -0,0 +1,51 @@
+import { Command } from "commander";
+import ora from "ora";
+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 { formatTable } from "../../lib/output/table.js";
+import { handleError } from "../../lib/errors/handler.js";
+export const listVersionsCommand = new Command("list")
+    .description("List versions for a project")
+    .argument("<project-slug>", "Project slug")
+    .option("--json", "Output as JSON")
+    .action(async (projectSlug, options) => {
+    const spinner = ora("Loading versions...").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 by slug
+        const project = await getProjectBySlug(client, projectSlug);
+        if (!project) {
+            spinner.fail(`Project '${projectSlug}' not found`);
+            process.exit(1);
+        }
+        const { versions, count } = await listVersions(client, project.id);
+        spinner.stop();
+        if (options.json) {
+            console.log(JSON.stringify({ versions, count }, null, 2));
+            return;
+        }
+        if (versions.length === 0) {
+            console.log(`\n✨ No versions yet for ${project.name}`);
+            return;
+        }
+        console.log(`\n📦 Versions for ${project.name} (${count}):\n`);
+        console.log(formatTable(["Version", "Status", "Git SHA", "Branch", "Uploaded"], versions.map((v) => [
+            v.semanticVersion || v.version || v.id,
+            v.status === "completed" ? "✓" : v.status,
+            v.gitSha?.substring(0, 7) || "-",
+            v.gitBranch || "-",
+            new Date(v.uploadDate).toLocaleString()
+        ])));
+    }
+    catch (error) {
+        spinner.fail("Failed to list versions");
+        handleError(error);
+    }
+});

package/dist/commands/whoami.d.ts

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

package/dist/commands/whoami.js

@@ -0,0 +1,52 @@
+import { Command } from "commander";
+import { ConfigManager } from "../lib/config/manager.js";
+import { RelesioAPIClient } from "../lib/api/client.js";
+import { OrganizationsAPI } from "../lib/api/organizations.js";
+import { colors, formatWarning } from "../lib/output/colors.js";
+import { outputJSON, shouldOutputJSON } from "../lib/output/formatter.js";
+export const whoamiCommand = new Command("whoami")
+    .description("Display current authentication status")
+    .action(async () => {
+    const config = ConfigManager.load();
+    if (!config.apiToken) {
+        if (shouldOutputJSON()) {
+            outputJSON({ authenticated: false });
+        }
+        else {
+            console.log(formatWarning("Not authenticated"));
+            console.log(colors.dim('Run "relesio auth login" to authenticate'));
+        }
+        return;
+    }
+    if (shouldOutputJSON()) {
+        // For JSON output, just show the config
+        outputJSON({
+            authenticated: true,
+            apiBaseUrl: config.apiBaseUrl,
+            currentOrgId: config.currentOrgId,
+            currentOrgName: config.currentOrgName
+        });
+        return;
+    }
+    // For table output, fetch additional info from API
+    const client = new RelesioAPIClient(config.apiBaseUrl, config.apiToken);
+    const orgsAPI = new OrganizationsAPI(client);
+    try {
+        const response = await orgsAPI.getUserOrgs();
+        console.log(colors.bold("\n Authentication Status"));
+        console.log(colors.dim("─".repeat(50)));
+        console.log(`Token:         ${colors.dim(config.apiToken.substring(0, 20))}...`);
+        console.log(`Current Org:   ${colors.highlight(config.currentOrgName || "None")} ${config.currentOrgId ? colors.dim(`(${config.currentOrgId})`) : ""}`);
+        console.log(`Organizations: ${response.organizations.length}`);
+        console.log(`API Base URL:  ${colors.dim(config.apiBaseUrl)}`);
+    }
+    catch (_error) {
+        // If API call fails, show what we have in config
+        console.log(colors.bold("\nAuthentication Status"));
+        console.log(colors.dim("─".repeat(50)));
+        console.log(`Token:        ${colors.dim(config.apiToken.substring(0, 20))}...`);
+        console.log(`Current Org:  ${colors.highlight(config.currentOrgName || "None")}`);
+        console.log(`API Base URL: ${colors.dim(config.apiBaseUrl)}`);
+        console.log(colors.dim("\n⚠ Could not fetch additional info from API"));
+    }
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};