@relesio/cli 0.2.6

package/dist/lib/api/types.d.ts

@@ -0,0 +1,89 @@
+export interface RequestOptions {
+    headers?: Record<string, string>;
+    query?: Record<string, string | number | boolean | undefined>;
+    timeout?: number;
+    /**
+     * When true, return the full API envelope (including meta/message)
+     * instead of unwrapping the `data` field.
+     */
+    raw?: boolean;
+    /**
+     * Organization ID to set in x-organization-id header
+     * Overrides default org from config
+     */
+    orgId?: string;
+}
+export interface APIResponse<T = unknown> {
+    message: string;
+    data: T;
+    pagination?: {
+        limit: number;
+        offset: number;
+        total: number;
+    };
+}
+export interface Organization {
+    id: string;
+    name: string;
+    slug: string | null;
+    imageUrl: string;
+    createdAt: string;
+    membersCount?: number;
+}
+export interface CreateOrganizationData {
+    name: string;
+    slug?: string;
+    publicMetadata?: Record<string, unknown>;
+}
+export interface UpdateOrganizationData {
+    name?: string;
+    slug?: string;
+    publicMetadata?: Record<string, unknown>;
+}
+export interface UserOrganization {
+    id: string;
+    name: string;
+    slug: string | null;
+    imageUrl: string;
+    isCurrent: boolean;
+    role: string;
+}
+export interface UserOrganizationsResponse {
+    organizations: UserOrganization[];
+    currentOrganizationId: string | null;
+}
+export interface Team {
+    id: string;
+    organizationId: string;
+    name: string;
+    description: string | null;
+    createdAt: string;
+    updatedAt: string;
+    memberCount?: number;
+}
+export interface CreateTeamData {
+    name: string;
+    description?: string;
+}
+export interface UpdateTeamData {
+    name?: string;
+    description?: string;
+}
+export interface TeamMember {
+    id: string;
+    teamId: string;
+    userId: string;
+    role: string;
+    createdAt: string;
+}
+export interface AddTeamMemberData {
+    userId: string;
+    role?: "admin" | "member";
+}
+export interface UpdateTeamMemberData {
+    role: "admin" | "member";
+}
+export interface PaginationQuery extends Record<string, number | undefined> {
+    limit?: number;
+    offset?: number;
+}

package/dist/lib/api/types.js

@@ -0,0 +1,2 @@
+// API Request and Response Types
+export {};

package/dist/lib/api/versions.d.ts

@@ -0,0 +1,140 @@
+import type { RelesioAPIClient } from "./client.js";
+import type { GitMetadata } from "../git/metadata.js";
+export interface Version {
+    id: string;
+    projectId: string;
+    version?: string;
+    snapshotId?: string;
+    semanticVersion?: string | null;
+    username?: string;
+    uploadId?: number;
+    gitSha?: string;
+    gitBranch?: string;
+    gitCommitMessage?: string;
+    gitAuthor?: string;
+    gitTag?: string | null;
+    uploadedBy: string;
+    uploadedByType?: string;
+    uploadedByName?: string;
+    uploadDate: string;
+    fileCount: number;
+    totalSizeBytes: number;
+    r2Prefix?: string;
+    status: "pending" | "uploading" | "completed" | "failed";
+    dependencies?: unknown[] | string;
+    metadata?: Record<string, unknown> | string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface FileManifest {
+    path: string;
+    contentType: string;
+    size: number;
+    checksum: string;
+}
+export interface CreateVersionInput {
+    version: string;
+    fileCount: number;
+    totalSizeBytes: number;
+    files: FileManifest[];
+    packageName?: string;
+    semanticVersion?: string;
+    dependencies?: unknown[];
+    metadata?: Record<string, unknown>;
+    gitSha?: string;
+    gitBranch?: string;
+    gitCommitMessage?: string;
+    gitAuthor?: string;
+    gitTag?: string;
+}
+export interface UploadUrl {
+    filePath: string;
+    r2Key: string;
+    uploadUrl: string;
+}
+export interface CreateVersionResponse {
+    versionId: string;
+    uploadUrls: UploadUrl[];
+    copiedFiles?: string[];
+    failedCopies?: Array<{
+        filePath: string;
+        reason: string;
+    }>;
+    stats?: {
+        toUpload: number;
+        copied: number;
+        failed: number;
+        uploadSizeBytes: number;
+        savedBytes: number;
+        alreadyExists?: boolean;
+        existingFileCount?: number;
+    };
+    previewUrl?: string;
+    message: string;
+}
+export interface Asset {
+    id: string;
+    versionId: string;
+    filePath: string;
+    sizeBytes: number;
+    contentType: string;
+    r2Key: string;
+    checksum: string;
+    createdAt: string;
+}
+export interface CompleteVersionInput {
+    assets: Array<{
+        filePath: string;
+        sizeBytes: number;
+        contentType: string;
+        r2Key: string;
+        checksum: string;
+    }>;
+    copiedAssets?: string[];
+}
+export interface CompleteVersionResponse {
+    versionId: string;
+    previewUrl: string;
+    fileCount: number;
+    totalSize: number;
+    message: string;
+}
+/**
+ * Create a new version (initiate upload)
+ */
+export declare function createVersion(client: RelesioAPIClient, projectId: string, input: CreateVersionInput): Promise<CreateVersionResponse>;
+/**
+ * Complete version upload
+ */
+export declare function completeVersion(client: RelesioAPIClient, projectId: string, versionId: string, input: CompleteVersionInput): Promise<CompleteVersionResponse>;
+/**
+ * List versions for a project
+ */
+export declare function listVersions(client: RelesioAPIClient, projectId: string): Promise<{
+    versions: Version[];
+    count: number;
+}>;
+/**
+ * Get version details
+ */
+export declare function getVersion(client: RelesioAPIClient, projectId: string, versionId: string): Promise<{
+    version: Version;
+}>;
+/**
+ * List assets for a version
+ */
+export declare function listAssets(client: RelesioAPIClient, projectId: string, versionId: string): Promise<{
+    assets: Asset[];
+    count: number;
+    totalSize: number;
+}>;
+/**
+ * Helper: Convert git metadata to API format
+ */
+export declare function gitMetadataToApiFormat(metadata: GitMetadata): {
+    gitSha?: string;
+    gitBranch?: string;
+    gitCommitMessage?: string;
+    gitAuthor?: string;
+    gitTag?: string;
+};

package/dist/lib/api/versions.js

@@ -0,0 +1,53 @@
+/**
+ * Create a new version (initiate upload)
+ */
+export async function createVersion(client, projectId, input) {
+    return client.post(`/v1/projects/${projectId}/versions`, input);
+}
+/**
+ * Complete version upload
+ */
+export async function completeVersion(client, projectId, versionId, input) {
+    return client.post(`/v1/projects/${projectId}/versions/${versionId}/complete`, input);
+}
+/**
+ * List versions for a project
+ */
+export async function listVersions(client, projectId) {
+    const response = await client.get(`/v1/projects/${projectId}/versions`, { raw: true });
+    return {
+        versions: response.data,
+        count: response.meta?.count ?? response.data.length
+    };
+}
+/**
+ * Get version details
+ */
+export async function getVersion(client, projectId, versionId) {
+    const response = await client.get(`/v1/projects/${projectId}/versions/${versionId}`, { raw: true });
+    return { version: response.data };
+}
+/**
+ * List assets for a version
+ */
+export async function listAssets(client, projectId, versionId) {
+    const response = await client.get(`/v1/projects/${projectId}/versions/${versionId}/assets`, { raw: true });
+    return {
+        assets: response.data,
+        count: response.meta?.count ?? response.data.length,
+        totalSize: response.meta?.totalSize ??
+            response.data.reduce((sum, a) => sum + (a.sizeBytes ?? 0), 0)
+    };
+}
+/**
+ * Helper: Convert git metadata to API format
+ */
+export function gitMetadataToApiFormat(metadata) {
+    return {
+        gitSha: metadata.sha,
+        gitBranch: metadata.branch,
+        gitCommitMessage: metadata.commitMessage,
+        gitAuthor: metadata.author,
+        gitTag: metadata.tag
+    };
+}

package/dist/lib/config/manager.d.ts

@@ -0,0 +1,35 @@
+import type { RelesioConfig } from "./types.js";
+declare class ConfigManagerClass {
+    private conf;
+    constructor();
+    /**
+     * Load the full configuration, merging environment variables with config file
+     */
+    load(): RelesioConfig;
+    /**
+     * Save partial configuration (merges with existing)
+     */
+    save(partialConfig: Partial<RelesioConfig>): void;
+    /**
+     * Get a specific config value
+     */
+    get<K extends keyof RelesioConfig>(key: K): RelesioConfig[K];
+    /**
+     * Set a specific config value
+     */
+    set<K extends keyof RelesioConfig>(key: K, value: RelesioConfig[K]): void;
+    /**
+     * Clear all configuration (logout)
+     */
+    clear(): void;
+    /**
+     * Get the config file path
+     */
+    getConfigPath(): string;
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated(): boolean;
+}
+export declare const ConfigManager: ConfigManagerClass;
+export {};

package/dist/lib/config/manager.js

@@ -0,0 +1,78 @@
+import Conf from "conf";
+import { DEFAULT_CONFIG } from "./types.js";
+class ConfigManagerClass {
+    conf;
+    constructor() {
+        this.conf = new Conf({
+            projectName: "relesio",
+            defaults: DEFAULT_CONFIG
+        });
+    }
+    /**
+     * Load the full configuration, merging environment variables with config file
+     */
+    load() {
+        const config = this.conf.store;
+        // Override with environment variables if present
+        return {
+            ...config,
+            apiToken: process.env.RELESIO_API_TOKEN || config.apiToken,
+            apiBaseUrl: process.env.RELESIO_API_URL || config.apiBaseUrl,
+            activeOrganizationId: process.env.RELESIO_ORG_ID || config.activeOrganizationId,
+            // Legacy field for backward compatibility
+            currentOrgId: process.env.RELESIO_ORG_ID || config.currentOrgId
+        };
+    }
+    /**
+     * Save partial configuration (merges with existing)
+     */
+    save(partialConfig) {
+        for (const [key, value] of Object.entries(partialConfig)) {
+            this.conf.set(key, value);
+        }
+    }
+    /**
+     * Get a specific config value
+     */
+    get(key) {
+        // Check environment variable first
+        if (key === "apiToken" && process.env.RELESIO_API_TOKEN) {
+            return process.env.RELESIO_API_TOKEN;
+        }
+        if (key === "apiBaseUrl" && process.env.RELESIO_API_URL) {
+            return process.env.RELESIO_API_URL;
+        }
+        if ((key === "activeOrganizationId" || key === "currentOrgId") &&
+            process.env.RELESIO_ORG_ID) {
+            return process.env.RELESIO_ORG_ID;
+        }
+        return this.conf.get(key);
+    }
+    /**
+     * Set a specific config value
+     */
+    set(key, value) {
+        this.conf.set(key, value);
+    }
+    /**
+     * Clear all configuration (logout)
+     */
+    clear() {
+        this.conf.clear();
+    }
+    /**
+     * Get the config file path
+     */
+    getConfigPath() {
+        return this.conf.path;
+    }
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated() {
+        const token = this.get("apiToken");
+        return token !== null && token !== "";
+    }
+}
+// Export singleton instance
+export const ConfigManager = new ConfigManagerClass();

package/dist/lib/config/types.d.ts

@@ -0,0 +1,15 @@
+export interface RelesioConfig {
+    apiToken: string | null;
+    apiBaseUrl: string;
+    userId: string | null;
+    userEmail: string | null;
+    userName: string | null;
+    activeOrganizationId: string | null;
+    activeOrganizationName: string | null;
+    activeOrganizationSlug: string | null;
+    currentOrgId: string | null;
+    currentOrgName: string | null;
+    output: "json" | "table";
+    colorOutput: boolean;
+}
+export declare const DEFAULT_CONFIG: RelesioConfig;

package/dist/lib/config/types.js

@@ -0,0 +1,15 @@
+export const DEFAULT_CONFIG = {
+    apiToken: null,
+    apiBaseUrl: "https://api.relesio.com",
+    userId: null,
+    userEmail: null,
+    userName: null,
+    activeOrganizationId: null,
+    activeOrganizationName: null,
+    activeOrganizationSlug: null,
+    // Legacy fields
+    currentOrgId: null,
+    currentOrgName: null,
+    output: "table",
+    colorOutput: true
+};

package/dist/lib/errors/handler.d.ts

@@ -0,0 +1 @@
+export declare function handleError(error: unknown): never;

package/dist/lib/errors/handler.js

@@ -0,0 +1,75 @@
+import chalk from "chalk";
+import { AuthenticationError, APIError, ConfigError, ValidationError } from "./types.js";
+import { APIError as ClientAPIError } from "../api/client.js";
+export function handleError(error) {
+    // Convert non-Error values to Error
+    if (!(error instanceof Error)) {
+        const stringError = typeof error === "string" ? error : JSON.stringify(error);
+        error = new Error(stringError);
+    }
+    // Authentication errors
+    if (error instanceof AuthenticationError) {
+        console.error(chalk.red("\n✗ Authentication Error"));
+        console.error(chalk.dim(error.message));
+        console.error(chalk.yellow("\nTip: Run 'relesio auth login' to authenticate"));
+        process.exit(1);
+    }
+    // API errors (from client)
+    if (error instanceof ClientAPIError || error instanceof APIError) {
+        const apiError = error;
+        console.error(chalk.red(`\n✗ API Error (${apiError.statusCode})`));
+        console.error(chalk.dim(apiError.message));
+        // Show response details in debug mode
+        if (process.env.DEBUG) {
+            console.error(chalk.dim("\n[DEBUG] Full Error Details:"));
+            console.error(chalk.dim(JSON.stringify({
+                message: apiError.message,
+                statusCode: apiError.statusCode,
+                response: apiError.response,
+                stack: apiError.stack
+            }, null, 2)));
+        }
+        // Specific status code handling
+        if (apiError.statusCode === 401) {
+            console.error(chalk.yellow("\nYour authentication may have expired. Try running 'relesio auth login'"));
+        }
+        else if (apiError.statusCode === 403) {
+            console.error(chalk.yellow("\nYou don't have permission to perform this action"));
+        }
+        else if (apiError.statusCode === 404) {
+            console.error(chalk.yellow("\nThe requested resource was not found"));
+        }
+        else if (apiError.statusCode === 0) {
+            console.error(chalk.yellow("\nNetwork error. Check your internet connection and try again"));
+        }
+        process.exit(1);
+    }
+    // Config errors
+    if (error instanceof ConfigError) {
+        console.error(chalk.red("\n✗ Configuration Error"));
+        console.error(chalk.dim(error.message));
+        process.exit(1);
+    }
+    // Validation errors
+    if (error instanceof ValidationError) {
+        console.error(chalk.red("\n✗ Validation Error"));
+        console.error(chalk.dim(error.message));
+        if (error.details) {
+            console.error(chalk.dim("\nDetails:"));
+            console.error(chalk.dim(JSON.stringify(error.details, null, 2)));
+        }
+        process.exit(1);
+    }
+    // Unknown errors (at this point, error is guaranteed to be an Error instance)
+    const err = error;
+    console.error(chalk.red("\n✗ Unexpected Error"));
+    console.error(chalk.dim(err.message));
+    if (process.env.DEBUG && err.stack) {
+        console.error(chalk.dim("\nStack trace:"));
+        console.error(chalk.dim(err.stack));
+    }
+    else {
+        console.error(chalk.dim("\nRun with DEBUG=1 environment variable for more details"));
+    }
+    process.exit(1);
+}

package/dist/lib/errors/types.d.ts

@@ -0,0 +1,19 @@
+export declare class RelesioError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+export declare class AuthenticationError extends RelesioError {
+    constructor(message?: string);
+}
+export declare class APIError extends RelesioError {
+    statusCode: number;
+    response?: unknown | undefined;
+    constructor(message: string, statusCode: number, response?: unknown | undefined);
+}
+export declare class ConfigError extends RelesioError {
+    constructor(message: string);
+}
+export declare class ValidationError extends RelesioError {
+    details?: unknown | undefined;
+    constructor(message: string, details?: unknown | undefined);
+}

package/dist/lib/errors/types.js

@@ -0,0 +1,34 @@
+export class RelesioError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "RelesioError";
+    }
+}
+export class AuthenticationError extends RelesioError {
+    constructor(message = "Not authenticated. Run 'relesio auth login' first") {
+        super(message, "AUTH_ERROR");
+    }
+}
+export class APIError extends RelesioError {
+    statusCode;
+    response;
+    constructor(message, statusCode, response) {
+        super(message, "API_ERROR");
+        this.statusCode = statusCode;
+        this.response = response;
+    }
+}
+export class ConfigError extends RelesioError {
+    constructor(message) {
+        super(message, "CONFIG_ERROR");
+    }
+}
+export class ValidationError extends RelesioError {
+    details;
+    constructor(message, details) {
+        super(message, "VALIDATION_ERROR");
+        this.details = details;
+    }
+}

package/dist/lib/files/scanner.d.ts

@@ -0,0 +1,23 @@
+export interface FileInfo {
+    path: string;
+    absolutePath: string;
+    size: number;
+    contentType: string;
+    checksum: string;
+}
+/**
+ * Scan directory recursively and collect file information
+ */
+export declare function scanDirectory(directoryPath: string, baseDir?: string): Promise<FileInfo[]>;
+/**
+ * Calculate SHA-256 checksum for a file
+ */
+export declare function calculateChecksum(filePath: string): Promise<string>;
+/**
+ * Format file size for display
+ */
+export declare function formatFileSize(bytes: number): string;
+/**
+ * Get total size of files
+ */
+export declare function getTotalSize(files: FileInfo[]): number;

package/dist/lib/files/scanner.js

@@ -0,0 +1,81 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+import { lookup as mimeTypeLookup } from "mime-types";
+/**
+ * Scan directory recursively and collect file information
+ */
+export async function scanDirectory(directoryPath, baseDir) {
+    const resolvedPath = path.resolve(directoryPath);
+    const base = baseDir || resolvedPath;
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`Directory does not exist: ${directoryPath}`);
+    }
+    const stats = fs.statSync(resolvedPath);
+    if (!stats.isDirectory()) {
+        throw new Error(`Not a directory: ${directoryPath}`);
+    }
+    const files = [];
+    const entries = fs.readdirSync(resolvedPath);
+    for (const entry of entries) {
+        const fullPath = path.join(resolvedPath, entry);
+        const entryStat = fs.statSync(fullPath);
+        // Skip hidden files and common directories to ignore
+        if (entry.startsWith(".") ||
+            entry === "node_modules" ||
+            entry === "dist" ||
+            entry === "__tests__") {
+            continue;
+        }
+        if (entryStat.isDirectory()) {
+            // Recursively scan subdirectory
+            const subFiles = await scanDirectory(fullPath, base);
+            files.push(...subFiles);
+        }
+        else if (entryStat.isFile()) {
+            // Calc relative path from base directory
+            const relativePath = path.relative(base, fullPath);
+            // Get content type
+            const contentType = mimeTypeLookup(fullPath) || "application/octet-stream";
+            // Calculate checksum
+            const checksum = await calculateChecksum(fullPath);
+            files.push({
+                path: relativePath.replace(/\\/g, "/"), // Normalize to forward slashes
+                absolutePath: fullPath,
+                size: entryStat.size,
+                contentType,
+                checksum
+            });
+        }
+    }
+    return files;
+}
+/**
+ * Calculate SHA-256 checksum for a file
+ */
+export async function calculateChecksum(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash("sha256");
+        const stream = fs.createReadStream(filePath);
+        stream.on("data", (data) => hash.update(data));
+        stream.on("end", () => resolve(hash.digest("hex")));
+        stream.on("error", reject);
+    });
+}
+/**
+ * Format file size for display
+ */
+export function formatFileSize(bytes) {
+    if (bytes === 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    const k = 1024;
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / k ** i).toFixed(2)} ${units[i]}`;
+}
+/**
+ * Get total size of files
+ */
+export function getTotalSize(files) {
+    return files.reduce((sum, file) => sum + file.size, 0);
+}