@relesio/cli 0.2.6

package/dist/index.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { Command } from "commander";
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
+import { authCommand } from "./commands/auth/index.js";
+import { organizationsCommand } from "./commands/organizations/index.js";
+import { teamCommand } from "./commands/team/index.js";
+import { whoamiCommand } from "./commands/whoami.js";
+import { projectsCommand } from "./commands/projects/index.js";
+import { versionsCommand } from "./commands/versions/index.js";
+import { uploadCommand } from "./commands/upload.js";
+import { deployCommand } from "./commands/deploy.js";
+import { rollbackCommand } from "./commands/rollback.js";
+import { statusCommand } from "./commands/status.js";
+import { handleError } from "./lib/errors/handler.js";
+const program = new Command();
+program
+    .name("relesio")
+    .description("CLI tool for Relesio - Modern Micro-Frontend Hosting")
+    .version(version)
+    .option("--org <org-id>", "Override organization context (ID or slug)")
+    .addHelpText("after", `
+Examples:
+  Authentication:
+    $ relesio auth login --token rls_...
+    $ relesio auth status
+    $ relesio auth logout
+
+  Organizations:
+    $ relesio organizations list
+    $ relesio organizations set <org-id>
+
+  Projects & Versions:
+    $ relesio projects list
+    $ relesio projects list --org my-org-slug
+    $ relesio versions list <project-slug>
+    $ relesio status <project-slug>
+
+  Upload & Deployment:
+    $ relesio upload ./dist --project my-app --version 1.0.0
+    $ relesio upload ./build -p my-app -v 1.0.1 --require-clean
+    $ relesio deploy <project-slug> [version] --env production
+    $ relesio deploy <project-slug> --latest --env staging
+    $ relesio rollback <project-slug> --env production
+
+  Teams:
+    $ relesio team list
+    $ relesio team get <teamId>
+
+Environment Variables:
+  RELESIO_API_TOKEN    API authentication token (starts with rls_)
+  RELESIO_API_URL      API base URL (default: https://api.relesio.com)
+  RELESIO_ORG_ID       Override organization context
+  DEBUG                Enable debug output
+
+Organization Context Priority:
+  1. --org flag (highest priority)
+  2. RELESIO_ORG_ID environment variable
+  3. Active organization from user session (default)
+`);
+// Add command groups
+program.addCommand(authCommand);
+program.addCommand(organizationsCommand);
+program.addCommand(teamCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(projectsCommand);
+program.addCommand(versionsCommand);
+program.addCommand(uploadCommand);
+program.addCommand(deployCommand);
+program.addCommand(rollbackCommand);
+program.addCommand(statusCommand);
+// Additional global options
+program.option("--json", "Output as JSON");
+program.option("--no-color", "Disable colored output");
+// Error handling
+program.exitOverride((err) => {
+    // Allow help to work normally
+    if (err.code === "commander.help" ||
+        err.code === "commander.helpDisplayed") {
+        process.exit(0);
+    }
+    if (err.code === "commander.version") {
+        process.exit(0);
+    }
+    // Handle other commander errors
+    handleError(err);
+});
+// Parse and execute
+program.parseAsync(process.argv).catch(handleError);

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

@@ -0,0 +1,32 @@
+import type { RequestOptions } from "./types.js";
+export declare class APIError extends Error {
+    statusCode: number;
+    response?: unknown | undefined;
+    constructor(message: string, statusCode: number, response?: unknown | undefined);
+}
+export declare class RelesioAPIClient {
+    private baseURL;
+    private token;
+    constructor(baseURL: string, token?: string | null);
+    setToken(token: string): void;
+    private buildURL;
+    private getHeaders;
+    /**
+     * Get organization ID from priority:
+     * 1. Explicit orgId parameter (--org flag)
+     * 2. RELESIO_ORG_ID env var
+     * 3. Active org from config
+     */
+    private getOrganizationContext;
+    /**
+     * Add organization context header if available
+     */
+    private withOrgContext;
+    request<T = unknown>(method: "GET" | "POST" | "PATCH" | "DELETE" | "PUT", endpoint: string, options?: RequestOptions & {
+        body?: unknown;
+    }): Promise<T>;
+    get<T = unknown>(endpoint: string, options?: RequestOptions): Promise<T>;
+    post<T = unknown>(endpoint: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    patch<T = unknown>(endpoint: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    delete<T = unknown>(endpoint: string, options?: RequestOptions): Promise<T>;
+}

package/dist/lib/api/client.js

@@ -0,0 +1,187 @@
+import { request } from "undici";
+import { ConfigManager } from "../config/manager.js";
+export class APIError extends Error {
+    statusCode;
+    response;
+    constructor(message, statusCode, response) {
+        super(message);
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = "APIError";
+    }
+}
+export class RelesioAPIClient {
+    baseURL;
+    token;
+    constructor(baseURL, token = null) {
+        this.baseURL = baseURL;
+        this.token = token;
+        // Ensure baseURL doesn't end with slash
+        this.baseURL = baseURL.replace(/\/$/, "");
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    buildURL(endpoint, query) {
+        // Ensure endpoint starts with slash
+        const path = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+        const url = `${this.baseURL}${path}`;
+        if (!query || Object.keys(query).length === 0) {
+            return url;
+        }
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query)) {
+            if (value !== undefined) {
+                params.append(key, String(value));
+            }
+        }
+        return `${url}?${params.toString()}`;
+    }
+    getHeaders(additionalHeaders) {
+        const headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "relesio-cli/0.1.0",
+            ...additionalHeaders
+        };
+        // Better Auth requires x-api-key header (not Authorization)
+        if (this.token) {
+            headers["x-api-key"] = this.token;
+        }
+        return headers;
+    }
+    /**
+     * Get organization ID from priority:
+     * 1. Explicit orgId parameter (--org flag)
+     * 2. RELESIO_ORG_ID env var
+     * 3. Active org from config
+     */
+    getOrganizationContext(explicitOrgId) {
+        // Priority 1: Explicit parameter
+        if (explicitOrgId) {
+            return explicitOrgId;
+        }
+        // Priority 2: Environment variable
+        if (process.env.RELESIO_ORG_ID) {
+            return process.env.RELESIO_ORG_ID;
+        }
+        // Priority 3: Active org from config
+        const config = ConfigManager.load();
+        return config.activeOrganizationId || null;
+    }
+    /**
+     * Add organization context header if available
+     */
+    withOrgContext(orgId) {
+        const resolvedOrgId = this.getOrganizationContext(orgId);
+        if (!resolvedOrgId) {
+            return {};
+        }
+        return { "x-organization-id": resolvedOrgId };
+    }
+    async request(method, endpoint, options) {
+        const url = this.buildURL(endpoint, options?.query);
+        const orgContextHeaders = this.withOrgContext(options?.orgId);
+        const headers = this.getHeaders({
+            ...orgContextHeaders,
+            ...options?.headers
+        });
+        // Debug logging
+        if (process.env.DEBUG) {
+            console.error(`\n[DEBUG] HTTP Request:`);
+            console.error(`  Method: ${method}`);
+            console.error(`  URL: ${url}`);
+            console.error(`  Headers:`, {
+                ...headers,
+                "x-api-key": headers["x-api-key"]
+                    ? `${headers["x-api-key"].substring(0, 15)}...`
+                    : undefined
+            });
+            if (options?.body) {
+                console.error(`  Body:`, JSON.stringify(options.body, null, 2));
+            }
+        }
+        try {
+            const response = await request(url, {
+                method: method,
+                headers,
+                body: options?.body ? JSON.stringify(options.body) : undefined,
+                bodyTimeout: options?.timeout || 60000, // Increased to 60s for slower connections
+                headersTimeout: options?.timeout || 60000
+            });
+            if (process.env.DEBUG) {
+                console.error(`\n[DEBUG] HTTP Response:`);
+                console.error(`  Status: ${response.statusCode}`);
+                console.error(`  Headers:`, response.headers);
+            }
+            const contentType = response.headers["content-type"];
+            const isJSON = contentType?.includes("application/json");
+            let data;
+            if (isJSON) {
+                const text = await response.body.text();
+                if (process.env.DEBUG) {
+                    console.error(`  Body (raw):`, text.substring(0, 500));
+                }
+                data = text ? JSON.parse(text) : null;
+            }
+            else {
+                data = await response.body.text();
+                if (process.env.DEBUG) {
+                    console.error(`  Body (text):`, String(data).substring(0, 500));
+                }
+            }
+            if (process.env.DEBUG) {
+                console.error(`  Parsed data:`, JSON.stringify(data, null, 2).substring(0, 500));
+            }
+            // Handle error responses
+            if (response.statusCode >= 400) {
+                const err = data;
+                const errorMessage = err?.message ?? err?.error ?? `HTTP ${response.statusCode}`;
+                throw new APIError(errorMessage, response.statusCode, data);
+            }
+            // Return the data property if it exists (standard API response), otherwise return the full response
+            if (options?.raw) {
+                return data;
+            }
+            const responseData = data;
+            return (responseData?.data ?? data);
+        }
+        catch (error) {
+            if (error instanceof APIError) {
+                throw error;
+            }
+            // Network or other errors
+            if (error instanceof Error) {
+                if (process.env.DEBUG) {
+                    console.error(`\n[DEBUG] Request Error:`);
+                    console.error(`  Message: ${error.message}`);
+                    console.error(`  Name: ${error.name}`);
+                    console.error(`  Stack:`, error.stack);
+                    console.error(`  Error object:`, error);
+                }
+                throw new APIError(`Request failed: ${error.message}`, 0, {
+                    originalError: error.message,
+                    errorName: error.name,
+                    errorStack: error.stack
+                });
+            }
+            if (process.env.DEBUG) {
+                console.error(`\n[DEBUG] Unknown error type:`, error);
+            }
+            throw new APIError("Unknown error occurred", 0, {
+                unknownError: String(error)
+            });
+        }
+    }
+    async get(endpoint, options) {
+        return this.request("GET", endpoint, options);
+    }
+    async post(endpoint, body, options) {
+        return this.request("POST", endpoint, { ...options, body });
+    }
+    async patch(endpoint, body, options) {
+        return this.request("PATCH", endpoint, { ...options, body });
+    }
+    async delete(endpoint, options) {
+        return this.request("DELETE", endpoint, options);
+    }
+}

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

@@ -0,0 +1,122 @@
+import type { RelesioAPIClient } from "./client.js";
+export interface Environment {
+    id: string;
+    organizationId: string;
+    name: string;
+    slug: string;
+    isProduction: boolean;
+    protected: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Deployment {
+    id: string;
+    environmentId: string;
+    versionId: string;
+    semanticVersion?: string | null;
+    deployedBy: string;
+    deployedByType: "user" | "api_token" | "service_account";
+    deployedAt: string;
+    deploymentType: "deploy" | "rollback";
+    previousVersionId?: string;
+    gitSha?: string;
+    gitBranch?: string;
+    metadata?: Record<string, unknown>;
+}
+export type DeploymentWithVersion = Deployment;
+export interface DeploymentHistoryItem {
+    deploymentId: string;
+    versionId: string;
+    semanticVersion?: string | null;
+    gitSha?: string | null;
+    gitBranch?: string | null;
+    deployedAt: string;
+    deployedBy: string;
+    deployedByType: "user" | "api_token";
+    deploymentType: "deploy" | "rollback";
+    metadata?: Record<string, unknown> | null;
+}
+export interface EnvironmentWithDeployment extends Environment {
+    currentDeployment: {
+        deploymentId: string;
+        versionId: string;
+        semanticVersion?: string | null;
+        deployedAt: string;
+        deployedBy: string;
+        version?: string;
+        deploymentType?: string;
+        gitSha?: string;
+        gitBranch?: string;
+    } | null;
+}
+export interface CreateDeploymentInput {
+    versionId: string;
+    projectId: string;
+    metadata?: Record<string, unknown>;
+}
+export interface CreateDeploymentResponse {
+    deployment: {
+        id: string;
+        environmentId: string;
+        versionId: string;
+        version: string;
+        deployedAt: string;
+    };
+    url: string;
+    message: string;
+}
+export interface RollbackResponse {
+    success: boolean;
+    version: string;
+    rolledBackFrom: string;
+    message: string;
+}
+/**
+ * List environments for the organization
+ * Note: Environments are organization-scoped, not project-scoped.
+ * The projectId parameter is kept for backward compatibility but not used for filtering.
+ */
+export declare function listEnvironments(client: RelesioAPIClient, _projectId?: string): Promise<{
+    environments: EnvironmentWithDeployment[];
+    count: number;
+}>;
+/**
+ * Deploy version to environment
+ */
+export declare function deployVersion(client: RelesioAPIClient, projectId: string, environmentId: string, input: CreateDeploymentInput): Promise<CreateDeploymentResponse>;
+/**
+ * Rollback to previous version
+ */
+export declare function rollback(client: RelesioAPIClient, projectId: string, environmentId: string): Promise<RollbackResponse>;
+/**
+ * Get deployment history for environment
+ */
+export declare function getDeploymentHistory(client: RelesioAPIClient, projectId: string, environmentId: string, limit?: number): Promise<{
+    deployments: DeploymentHistoryItem[];
+    count: number;
+}>;
+/**
+ * Get deployment status for all environments
+ */
+export declare function getDeploymentStatus(client: RelesioAPIClient, projectId: string): Promise<{
+    project: {
+        id: string;
+        name: string;
+        slug: string;
+    };
+    status: Array<{
+        environment: Environment;
+        currentDeployment: {
+            deploymentId: string;
+            versionId: string;
+            semanticVersion?: string | null;
+            version: string;
+            deployedAt: string;
+            deployedBy: string;
+        } | null;
+    }>;
+}>;
+/**
+ * Helper: Get environment by slug
+ */
+export declare function getEnvironmentBySlug(client: RelesioAPIClient, projectId: string, slug: string): Promise<EnvironmentWithDeployment | null>;

package/dist/lib/api/deployments.js

@@ -0,0 +1,55 @@
+/**
+ * List environments for the organization
+ * Note: Environments are organization-scoped, not project-scoped.
+ * The projectId parameter is kept for backward compatibility but not used for filtering.
+ */
+export async function listEnvironments(client, _projectId) {
+    const response = await client.get("/v1/environments", { raw: true, query: { limit: 100 } });
+    // Environments are organization-scoped, so no filtering needed
+    // The API already returns only environments for the authenticated organization
+    return {
+        environments: response.data,
+        count: response.meta?.count ?? response.data.length
+    };
+}
+/**
+ * Deploy version to environment
+ */
+export async function deployVersion(client, projectId, environmentId, input) {
+    return client.post(`/v1/environments/${environmentId}/deployments`, { ...input, projectId });
+}
+/**
+ * Rollback to previous version
+ */
+export async function rollback(client, projectId, environmentId) {
+    return client.post(`/v1/environments/${environmentId}/rollback`, { projectId });
+}
+/**
+ * Get deployment history for environment
+ */
+export async function getDeploymentHistory(client, projectId, environmentId, limit = 50) {
+    const response = await client.get(`/v1/environments/${environmentId}/deployments`, {
+        query: { projectId, limit },
+        raw: true
+    });
+    return {
+        deployments: response.data.map((d) => ({
+            ...d,
+            deploymentId: d.deploymentId
+        })),
+        count: response.meta?.count ?? response.data.length
+    };
+}
+/**
+ * Get deployment status for all environments
+ */
+export async function getDeploymentStatus(client, projectId) {
+    return client.get(`/v1/projects/${projectId}/deployments/status`);
+}
+/**
+ * Helper: Get environment by slug
+ */
+export async function getEnvironmentBySlug(client, projectId, slug) {
+    const { environments } = await listEnvironments(client, projectId);
+    return environments.find((env) => env.slug === slug) || null;
+}

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

@@ -0,0 +1,27 @@
+import type { RelesioAPIClient } from "./client.js";
+import type { Organization, CreateOrganizationData, UpdateOrganizationData, UserOrganizationsResponse } from "./types.js";
+export declare class OrganizationsAPI {
+    private client;
+    constructor(client: RelesioAPIClient);
+    list(): Promise<Organization[]>;
+    create(data: CreateOrganizationData): Promise<Organization>;
+    get(orgId: string): Promise<Organization>;
+    update(orgId: string, data: UpdateOrganizationData): Promise<Organization>;
+    delete(orgId: string): Promise<void>;
+    switch(orgId: string): Promise<{
+        organizationId: string;
+        organizationName: string;
+    }>;
+    getUserOrgs(): Promise<UserOrganizationsResponse>;
+    /**
+     * Validate API token and get organization info
+     * Uses API key authentication (rls_...)
+     *
+     * @deprecated Use /v1/api-token/me endpoint for richer context (includes user info, all orgs)
+     */
+    validateApiToken(): Promise<{
+        organizationId: string;
+        organizationName: string;
+        tokenId: string;
+    }>;
+}

package/dist/lib/api/organizations.js

@@ -0,0 +1,37 @@
+export class OrganizationsAPI {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async list() {
+        return this.client.get("/v1/organizations");
+    }
+    async create(data) {
+        return this.client.post("/v1/organizations", data);
+    }
+    async get(orgId) {
+        return this.client.get(`/v1/organizations/${orgId}`);
+    }
+    async update(orgId, data) {
+        return this.client.patch(`/v1/organizations/${orgId}`, data);
+    }
+    async delete(orgId) {
+        return this.client.delete(`/v1/organizations/${orgId}`);
+    }
+    async switch(orgId) {
+        return this.client.post("/v1/users/me/organization", { organizationId: orgId });
+    }
+    async getUserOrgs() {
+        return this.client.get("/v1/users/me/organizations");
+    }
+    /**
+     * Validate API token and get organization info
+     * Uses API key authentication (rls_...)
+     *
+     * @deprecated Use /v1/api-token/me endpoint for richer context (includes user info, all orgs)
+     */
+    async validateApiToken() {
+        // Note: client.get() already extracts the .data property from API responses
+        return this.client.get("/v1/api-token/validate");
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { RelesioAPIClient } from "./client.js";
+export interface Project {
+    id: string;
+    organizationId: string;
+    name: string;
+    slug: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateProjectInput {
+    name: string;
+    slug: string;
+}
+export interface ListProjectsResponse {
+    projects: Project[];
+    count: number;
+}
+/**
+ * List all projects for the organization
+ */
+export declare function listProjects(client: RelesioAPIClient): Promise<ListProjectsResponse>;
+/**
+ * Get project by ID
+ */
+export declare function getProject(client: RelesioAPIClient, projectId: string): Promise<{
+    project: Project;
+}>;
+/**
+ * Create a new project
+ */
+export declare function createProject(client: RelesioAPIClient, input: CreateProjectInput): Promise<{
+    project: Project;
+    message: string;
+}>;
+/**
+ * Get project by slug (helper)
+ */
+export declare function getProjectBySlug(client: RelesioAPIClient, slug: string): Promise<Project | null>;

package/dist/lib/api/projects.js

@@ -0,0 +1,34 @@
+/**
+ * List all projects for the organization
+ */
+export async function listProjects(client) {
+    const response = await client.get("/v1/projects", { raw: true });
+    return {
+        projects: response.data,
+        count: response.meta?.count ?? response.data.length
+    };
+}
+/**
+ * Get project by ID
+ */
+export async function getProject(client, projectId) {
+    const response = await client.get(`/v1/projects/${projectId}`, { raw: true });
+    return { project: response.data };
+}
+/**
+ * Create a new project
+ */
+export async function createProject(client, input) {
+    const response = await client.post("/v1/projects", input, { raw: true });
+    return {
+        project: response.data,
+        message: response.message ?? "Project created"
+    };
+}
+/**
+ * Get project by slug (helper)
+ */
+export async function getProjectBySlug(client, slug) {
+    const { projects } = await listProjects(client);
+    return projects.find((p) => p.slug === slug) || null;
+}

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

@@ -0,0 +1,15 @@
+import type { RelesioAPIClient } from "./client.js";
+import type { Team, CreateTeamData, UpdateTeamData, TeamMember, AddTeamMemberData, UpdateTeamMemberData, PaginationQuery, APIResponse } from "./types.js";
+export declare class TeamsAPI {
+    private client;
+    constructor(client: RelesioAPIClient);
+    list(query?: PaginationQuery): Promise<APIResponse<Team[]>>;
+    create(data: CreateTeamData): Promise<Team>;
+    get(teamId: string): Promise<Team>;
+    update(teamId: string, data: UpdateTeamData): Promise<Team>;
+    delete(teamId: string): Promise<void>;
+    listMembers(teamId: string, query?: PaginationQuery): Promise<APIResponse<TeamMember[]>>;
+    addMember(teamId: string, data: AddTeamMemberData): Promise<TeamMember>;
+    updateMember(teamId: string, memberId: string, data: UpdateTeamMemberData): Promise<TeamMember>;
+    removeMember(teamId: string, memberId: string): Promise<void>;
+}

package/dist/lib/api/teams.js

@@ -0,0 +1,44 @@
+export class TeamsAPI {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async list(query) {
+        const response = await this.client.get("/v1/teams", { query, raw: true });
+        return {
+            data: response.data,
+            message: response.message ?? "Teams retrieved",
+            pagination: response.meta?.pagination
+        };
+    }
+    async create(data) {
+        return this.client.post("/v1/teams", data);
+    }
+    async get(teamId) {
+        return this.client.get(`/v1/teams/${teamId}`);
+    }
+    async update(teamId, data) {
+        return this.client.patch(`/v1/teams/${teamId}`, data);
+    }
+    async delete(teamId) {
+        return this.client.delete(`/v1/teams/${teamId}`);
+    }
+    // Team Members
+    async listMembers(teamId, query) {
+        const response = await this.client.get(`/v1/teams/${teamId}/members`, { query, raw: true });
+        return {
+            data: response.data,
+            message: response.message ?? "Team members retrieved",
+            pagination: response.meta?.pagination
+        };
+    }
+    async addMember(teamId, data) {
+        return this.client.post(`/v1/teams/${teamId}/members`, data);
+    }
+    async updateMember(teamId, memberId, data) {
+        return this.client.patch(`/v1/teams/${teamId}/members/${memberId}`, data);
+    }
+    async removeMember(teamId, memberId) {
+        return this.client.delete(`/v1/teams/${teamId}/members/${memberId}`);
+    }
+}