onflyt-cli 1.0.1-beta.1 → 1.0.1-beta.3

package/dist/lib/api.d.ts

@@ -0,0 +1,27 @@
+export interface ApiError {
+    success: false;
+    error: string;
+    code?: string;
+}
+export interface ApiSuccess<T> {
+    success: true;
+    data: T;
+}
+export type ApiResponse<T> = ApiError | ApiSuccess<T>;
+export declare class ApiClient {
+    private token;
+    constructor();
+    setToken(token: string): void;
+    private request;
+    get<T>(endpoint: string): Promise<T>;
+    post<T>(endpoint: string, body?: unknown): Promise<T>;
+    patch<T>(endpoint: string, body?: unknown): Promise<T>;
+    delete<T>(endpoint: string): Promise<T>;
+    uploadFile<T>(endpoint: string, filePath: string, filename: string, onProgress?: (uploaded: number, total: number) => void): Promise<T>;
+}
+export declare class ApiException extends Error {
+    status: number;
+    code?: string | undefined;
+    constructor(message: string, status: number, code?: string | undefined);
+}
+export declare const api: ApiClient;

package/dist/lib/api.js

@@ -0,0 +1,109 @@
+import { API_URL, getConfig } from "./config.js";
+export class ApiClient {
+    token;
+    constructor() {
+        const config = getConfig();
+        this.token = config.token || null;
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    async request(endpoint, options = {}) {
+        const headers = {
+            "Content-Type": "application/json",
+            ...(options.headers || {}),
+        };
+        if (this.token) {
+            headers["Authorization"] = `Bearer ${this.token}`;
+        }
+        const response = await fetch(`${API_URL}${endpoint}`, {
+            ...options,
+            headers,
+        });
+        const text = await response.text();
+        if (!response.ok) {
+            let errorMessage = `Request failed with status ${response.status}`;
+            try {
+                const data = JSON.parse(text);
+                errorMessage = data.error || errorMessage;
+            }
+            catch { }
+            throw new ApiException(errorMessage, response.status);
+        }
+        if (!text) {
+            return {};
+        }
+        try {
+            const data = JSON.parse(text);
+            if (data.success === false) {
+                throw new ApiException(data.error || "Request failed", response.status, data.code);
+            }
+            if (data.success === true) {
+                return data.data || data;
+            }
+            return data;
+        }
+        catch {
+            return text;
+        }
+    }
+    async get(endpoint) {
+        return this.request(endpoint, { method: "GET" });
+    }
+    async post(endpoint, body) {
+        return this.request(endpoint, {
+            method: "POST",
+            body: body ? JSON.stringify(body) : undefined,
+        });
+    }
+    async patch(endpoint, body) {
+        return this.request(endpoint, {
+            method: "PATCH",
+            body: body ? JSON.stringify(body) : undefined,
+        });
+    }
+    async delete(endpoint) {
+        return this.request(endpoint, { method: "DELETE" });
+    }
+    async uploadFile(endpoint, filePath, filename, onProgress) {
+        const { readFileSync } = await import("fs");
+        const fileBuffer = readFileSync(filePath);
+        const totalSize = fileBuffer.length;
+        const response = await fetch(`${API_URL}${endpoint}`, {
+            method: "POST",
+            body: fileBuffer,
+            headers: {
+                "Content-Type": "application/zip",
+                "Content-Length": String(totalSize),
+                Authorization: this.token ? `Bearer ${this.token}` : "",
+            },
+        });
+        const text = await response.text();
+        if (!response.ok) {
+            let errorMessage = `Upload failed with status ${response.status}`;
+            try {
+                const data = JSON.parse(text);
+                errorMessage = data.error || errorMessage;
+            }
+            catch { }
+            throw new ApiException(errorMessage, response.status);
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+}
+export class ApiException extends Error {
+    status;
+    code;
+    constructor(message, status, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "ApiException";
+    }
+}
+export const api = new ApiClient();

package/dist/lib/config.d.ts

@@ -0,0 +1,32 @@
+export declare const API_URL: string;
+export interface Config {
+    token?: string;
+    user?: {
+        id: string;
+        email: string;
+        name: string;
+        avatar?: string;
+    };
+    defaultTeam?: string;
+    lastLogin?: string;
+}
+export declare function getConfig(): Config;
+export declare function saveConfig(config: Config): void;
+export declare function clearConfig(): void;
+export declare function isLoggedIn(): boolean;
+export interface ProjectConfig {
+    id?: string;
+    name: string;
+    teamId?: string;
+    framework: string;
+    buildCommand?: string;
+    outputDirectory?: string;
+    installCommand?: string;
+    startCommand?: string;
+    gitRepoUrl?: string;
+    gitBranch?: string;
+    gitRepoId?: number;
+}
+export declare function getProjectConfig(cwd?: string): ProjectConfig | null;
+export declare function saveProjectConfig(config: ProjectConfig, cwd?: string): void;
+export declare function hasProjectConfig(cwd?: string): boolean;

package/dist/lib/config.js

@@ -0,0 +1,52 @@
+import { homedir } from "os";
+import { join } from "path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+const CONFIG_DIR = join(homedir(), ".onflyt");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+const PROJECT_CONFIG_FILE = "onflyt.json";
+export const API_URL = process.env.ONFLYT_API_URL || "";
+export function getConfig() {
+    try {
+        if (existsSync(CONFIG_FILE)) {
+            return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+        }
+    }
+    catch {
+        // Return empty config if file doesn't exist or is invalid
+    }
+    return {};
+}
+export function saveConfig(config) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function clearConfig() {
+    if (existsSync(CONFIG_FILE)) {
+        const config = getConfig();
+        saveConfig({});
+    }
+}
+export function isLoggedIn() {
+    const config = getConfig();
+    return !!config.token;
+}
+export function getProjectConfig(cwd = process.cwd()) {
+    try {
+        const configPath = join(cwd, PROJECT_CONFIG_FILE);
+        if (existsSync(configPath)) {
+            return JSON.parse(readFileSync(configPath, "utf-8"));
+        }
+    }
+    catch {
+        // Return null if file doesn't exist or is invalid
+    }
+    return null;
+}
+export function saveProjectConfig(config, cwd = process.cwd()) {
+    const configPath = join(cwd, PROJECT_CONFIG_FILE);
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+export function hasProjectConfig(cwd = process.cwd()) {
+    const configPath = join(cwd, PROJECT_CONFIG_FILE);
+    return existsSync(configPath);
+}

package/dist/lib/deploy-api.d.ts

@@ -0,0 +1,97 @@
+import { PodTier } from "./shared";
+import { TeamLimits } from "./shared";
+export interface Team {
+    teamId: string;
+    role: string;
+    team: {
+        id: string;
+        name: string;
+        slug: string;
+        plan: string;
+    };
+}
+export interface Balance {
+    balanceUSD: number;
+    balanceFormatted: string;
+}
+export interface ProjectConfig {
+    name: string;
+    framework?: string;
+    buildCommand?: string;
+    outputDirectory?: string;
+    installCommand?: string;
+    startCommand?: string;
+    gitRepoUrl?: string;
+    gitBranch?: string;
+}
+export interface InstanceOption {
+    id: PodTier;
+    label: string;
+    cpu: string;
+    ram: string;
+    disk: string;
+    maxReplicas: number;
+    hourly: string;
+}
+export declare const INSTANCE_OPTIONS: InstanceOption[];
+export declare function isPodProject(framework?: string): boolean;
+export declare function getDeploymentType(framework?: string): "static" | "container";
+export declare function getProjectConfig(): ProjectConfig | null;
+export declare function loadTeamsWithBalances(): Promise<{
+    teams: Team[];
+    balances: Record<string, Balance>;
+}>;
+export declare function getTeamDetails(teamId: string): Promise<{
+    totalLifetimeSpend: number;
+    balanceUSD: number;
+}>;
+export declare function getTeamLimits(totalSpend: number): TeamLimits;
+export declare function getTeamPlanLabel(totalSpend: number): string;
+export declare function findOrCreateProject(teamId: string, projectName: string, framework?: string, gitUrl?: string, instanceSize?: PodTier, maxInstances?: number): Promise<{
+    id: string;
+    name: string;
+    isNew: boolean;
+    existingProject?: any;
+}>;
+export declare function updateProjectSettings(projectId: string, instanceSize?: PodTier, maxInstances?: number): Promise<void>;
+export declare function getProjectDetails(projectId: string): Promise<any>;
+export declare function startDeployment(projectId: string, branch?: string, instanceSize?: PodTier, replicas?: number, envVars?: Array<{
+    key: string;
+    value: string;
+}>): Promise<string>;
+export type DeploymentStatus = "queued" | "building" | "provisioning" | "deployed" | "failed";
+export interface DeploymentDetails {
+    status: DeploymentStatus;
+    url?: string;
+    previewUrl?: string;
+}
+export declare function getDeploymentStatus(deploymentId: string): Promise<DeploymentDetails>;
+export declare function streamLogs(deploymentId: string, onLog: (log: string) => void, onError: () => void): () => void;
+export interface StoredLog {
+    timestamp: number;
+    level: "error" | "warn" | "info" | "debug";
+    message: string;
+    source?: "build" | "runtime";
+    replicaIndex?: number;
+}
+export interface StoredLogsResult {
+    logs: StoredLog[];
+    total: number;
+    hasMore: boolean;
+}
+export declare function getStoredLogs(deploymentId: string, options?: {
+    source?: "build" | "runtime";
+    replicaIndex?: number;
+    limit?: number;
+    offset?: number;
+    search?: string;
+}): Promise<StoredLogsResult>;
+export declare function createProjectZip(sourceDir: string, outputPath: string, excludePatterns?: string[]): Promise<string>;
+export declare function deployManual(projectId: string, zipPath: string, framework?: string, instanceSize?: PodTier, replicas?: number, envVars?: Array<{
+    key: string;
+    value: string;
+}>, onUploadProgress?: (uploaded: number, total: number) => void, buildSettings?: {
+    buildCommand?: string;
+    outputDirectory?: string;
+    installCommand?: string;
+}): Promise<string>;

package/dist/lib/deploy-api.js

@@ -0,0 +1,335 @@
+import { api } from "./api.js";
+import { getConfig, API_URL } from "./config.js";
+import { readFileSync, existsSync, unlinkSync, } from "fs";
+import { execSync } from "child_process";
+import { TIER_HOURLY_PRICE } from "./shared";
+import { getLimitsBySpend, getTierLabel } from "./shared";
+export const INSTANCE_OPTIONS = [
+    {
+        id: "micro",
+        label: "Micro",
+        cpu: "0.25",
+        ram: "1GB",
+        disk: "4GB",
+        maxReplicas: 1,
+        hourly: "Free",
+    },
+    {
+        id: "lite",
+        label: "Lite",
+        cpu: "0.25",
+        ram: "1GB",
+        disk: "4GB",
+        maxReplicas: 2,
+        hourly: formatPrice(TIER_HOURLY_PRICE.lite),
+    },
+    {
+        id: "standard",
+        label: "Standard",
+        cpu: "0.5",
+        ram: "4GB",
+        disk: "8GB",
+        maxReplicas: 4,
+        hourly: formatPrice(TIER_HOURLY_PRICE.standard),
+    },
+    {
+        id: "pro",
+        label: "Pro",
+        cpu: "1",
+        ram: "6GB",
+        disk: "12GB",
+        maxReplicas: 4,
+        hourly: formatPrice(TIER_HOURLY_PRICE.pro),
+    },
+    {
+        id: "business",
+        label: "Business",
+        cpu: "2",
+        ram: "8GB",
+        disk: "16GB",
+        maxReplicas: 10,
+        hourly: formatPrice(TIER_HOURLY_PRICE.business),
+    },
+];
+function formatPrice(price) {
+    if (price === 0)
+        return "Free";
+    return `$${price.toFixed(3)}/hr`;
+}
+import { FRAMEWORKS } from "./shared";
+export function isPodProject(framework) {
+    if (!framework)
+        return false;
+    const config = FRAMEWORKS[framework.toLowerCase()];
+    if (!config)
+        return false;
+    return config.deploymentType === "container";
+}
+export function getDeploymentType(framework) {
+    if (!framework)
+        return "static";
+    const config = FRAMEWORKS[framework.toLowerCase()];
+    if (!config)
+        return "static";
+    return config.deploymentType;
+}
+export function getProjectConfig() {
+    try {
+        const configData = JSON.parse(readFileSync(`${process.cwd()}/onflyt.json`, "utf-8"));
+        return configData;
+    }
+    catch {
+        return null;
+    }
+}
+export async function loadTeamsWithBalances() {
+    const config = getConfig();
+    api.setToken(config.token);
+    const meData = await api.get("/auth/me");
+    const teams = meData.teams || [];
+    const balances = {};
+    await Promise.all(teams.map(async (team) => {
+        try {
+            const balanceData = await api.get(`/billing/balance?teamId=${team.team.id}`);
+            balances[team.team.id] = balanceData.data || balanceData;
+        }
+        catch {
+            balances[team.team.id] = {
+                balanceUSD: 0,
+                balanceFormatted: "$0.00",
+            };
+        }
+    }));
+    return { teams, balances };
+}
+export async function getTeamDetails(teamId) {
+    try {
+        const teamData = await api.get(`/teams/${teamId}`);
+        const team = teamData.team || teamData;
+        return {
+            totalLifetimeSpend: team.totalLifetimeSpend || 0,
+            balanceUSD: team.balanceUSD || 0,
+        };
+    }
+    catch {
+        return { totalLifetimeSpend: 0, balanceUSD: 0 };
+    }
+}
+export function getTeamLimits(totalSpend) {
+    return getLimitsBySpend(totalSpend);
+}
+export function getTeamPlanLabel(totalSpend) {
+    return getTierLabel(totalSpend);
+}
+export async function findOrCreateProject(teamId, projectName, framework, gitUrl, instanceSize, maxInstances) {
+    const projectsRes = await api.get(`/projects/team/${teamId}`);
+    const existingProjects = projectsRes.projects || [];
+    const existing = existingProjects.find((p) => p.name === projectName);
+    if (existing) {
+        return {
+            id: existing.id,
+            name: existing.name,
+            isNew: false,
+            existingProject: existing,
+        };
+    }
+    const createRes = await api.post("/projects", {
+        name: projectName,
+        framework: framework || "static",
+        teamId,
+        gitRepoUrl: gitUrl || null,
+        instanceSize,
+        maxInstances,
+    });
+    const project = createRes.project || createRes;
+    return { id: project.id, name: project.name, isNew: true };
+}
+export async function updateProjectSettings(projectId, instanceSize, maxInstances) {
+    const updates = {};
+    if (instanceSize)
+        updates.instanceSize = instanceSize;
+    if (maxInstances)
+        updates.maxInstances = maxInstances;
+    if (Object.keys(updates).length > 0) {
+        await api.patch(`/projects/${projectId}`, updates);
+    }
+}
+export async function getProjectDetails(projectId) {
+    const res = await api.get(`/projects/${projectId}`);
+    return res.project || res;
+}
+export async function startDeployment(projectId, branch, instanceSize, replicas, envVars) {
+    const deployRes = await api.post(`/deployments/${projectId}/deploy`, {
+        branch: branch || "main",
+        instanceSize,
+        replicas,
+        envVars,
+    });
+    return deployRes.deploymentId;
+}
+export async function getDeploymentStatus(deploymentId) {
+    const res = await api.get(`/deployments/detail/${deploymentId}`);
+    const rawStatus = (res.status ||
+        res.deployment?.status ||
+        "queued").toLowerCase();
+    if (rawStatus === "queued" || rawStatus === "uploaded") {
+        return { status: "queued" };
+    }
+    if (rawStatus === "building") {
+        return { status: "building" };
+    }
+    if (rawStatus === "live" || rawStatus === "running") {
+        return {
+            status: "deployed",
+            url: res.deployment?.url || res.deployment?.previewUrl,
+        };
+    }
+    if (rawStatus === "failed") {
+        return { status: "failed" };
+    }
+    return { status: "queued" };
+}
+export function streamLogs(deploymentId, onLog, onError) {
+    let cancelled = false;
+    const startStream = async () => {
+        try {
+            const response = await fetch(`${API_URL}/deployments/${deploymentId}/logs/stream`, {
+                headers: { Authorization: `Bearer ${getConfig().token}` },
+            });
+            if (!response.body) {
+                onError();
+                return;
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            const read = () => {
+                if (cancelled)
+                    return;
+                reader.read().then(({ done, value }) => {
+                    if (done || cancelled)
+                        return;
+                    const chunk = decoder.decode(value);
+                    const lines = chunk.split("\n").filter((l) => l.startsWith("data:"));
+                    lines.forEach((l) => {
+                        const log = l.replace("data: ", "").trim();
+                        if (log)
+                            onLog(log);
+                    });
+                    read();
+                });
+            };
+            read();
+        }
+        catch {
+            if (!cancelled)
+                onError();
+        }
+    };
+    startStream();
+    return () => {
+        cancelled = true;
+    };
+}
+export async function getStoredLogs(deploymentId, options) {
+    const params = new URLSearchParams();
+    if (options?.source)
+        params.set("source", options.source);
+    if (options?.replicaIndex !== undefined)
+        params.set("replicaIndex", String(options.replicaIndex));
+    if (options?.limit)
+        params.set("limit", String(options.limit));
+    if (options?.offset)
+        params.set("offset", String(options.offset));
+    if (options?.search)
+        params.set("search", options.search);
+    const queryString = params.toString();
+    const endpoint = `/logs/deployments/${deploymentId}/logs${queryString ? `?${queryString}` : ""}`;
+    const res = await api.get(endpoint);
+    return {
+        logs: res.logs || [],
+        total: res.total || 0,
+        hasMore: res.hasMore || false,
+    };
+}
+const DEFAULT_EXCLUDE_PATTERNS = [
+    "node_modules",
+    ".git",
+    ".gitignore",
+    ".env",
+    ".env.local",
+    ".env.*.local",
+    "dist",
+    "build",
+    ".next",
+    ".output",
+    ".svelte-kit",
+    ".turbo",
+    ".vercel",
+    ".netlify",
+    "coverage",
+    ".nyc_output",
+    "*.log",
+    "npm-debug.log*",
+    "yarn-debug.log*",
+    "yarn-error.log*",
+    ".DS_Store",
+    "Thumbs.db",
+    ".cache",
+    ".parcel-cache",
+    ".vite",
+    ".nuxt",
+    ".output",
+    "__pycache__",
+    "*.pyc",
+    ".pytest_cache",
+    "venv",
+    ".venv",
+    "*.egg-info",
+    "vendor",
+    ".idea",
+    ".vscode",
+    "*.swp",
+    "*.swo",
+];
+export function createProjectZip(sourceDir, outputPath, excludePatterns = DEFAULT_EXCLUDE_PATTERNS) {
+    return new Promise((resolve, reject) => {
+        const excludeStr = excludePatterns.map((p) => `-x "${p}"`).join(" ");
+        try {
+            execSync(`cd "${sourceDir}" && zip -r "${outputPath}" . -q ${excludeStr}`, { maxBuffer: 50 * 1024 * 1024 });
+            resolve(outputPath);
+        }
+        catch (error) {
+            reject(new Error(`Failed to create zip: ${error.message}`));
+        }
+    });
+}
+export async function deployManual(projectId, zipPath, framework, instanceSize, replicas, envVars, onUploadProgress, buildSettings) {
+    try {
+        const uploadRes = await api.uploadFile(`/deployments/${projectId}/upload`, zipPath, "project.zip", onUploadProgress);
+        const updates = {};
+        if (instanceSize)
+            updates.instanceSize = instanceSize;
+        if (replicas)
+            updates.maxInstances = replicas;
+        if (buildSettings?.buildCommand)
+            updates.buildCommand = buildSettings.buildCommand;
+        if (buildSettings?.outputDirectory)
+            updates.outputDirectory = buildSettings.outputDirectory;
+        if (buildSettings?.installCommand)
+            updates.installCommand = buildSettings.installCommand;
+        if (Object.keys(updates).length > 0) {
+            await api.patch(`/projects/${projectId}`, updates);
+        }
+        unlinkSync(zipPath);
+        return uploadRes.deploymentId;
+    }
+    catch (error) {
+        if (existsSync(zipPath)) {
+            try {
+                unlinkSync(zipPath);
+            }
+            catch { }
+        }
+        throw new Error(`Manual deploy failed: ${error.message}`);
+    }
+}

package/dist/lib/deploy.d.ts

@@ -0,0 +1,36 @@
+export interface DeployProgress {
+    stage: "zipping" | "uploading" | "building" | "deployed";
+    progress?: number;
+    message?: string;
+    url?: string;
+}
+export interface ProjectConfig {
+    id?: string;
+    name: string;
+    teamId: string;
+    framework: string;
+    buildCommand?: string;
+    outputDirectory?: string;
+    installCommand?: string;
+    startCommand?: string;
+    gitRepoUrl?: string;
+    gitBranch?: string;
+    gitRepoId?: number;
+}
+export declare class DeployHelper {
+    private cwd;
+    private onProgress?;
+    constructor(cwd?: string, onProgress?: (p: DeployProgress) => void);
+    report(progress: DeployProgress): void;
+    createZip(): Promise<Buffer>;
+    private gzip;
+    uploadZip(zipData: Buffer, projectId: string, apiUrl: string, token: string, onProgress?: (loaded: number, total: number) => void): Promise<{
+        deploymentId: string;
+    }>;
+    private buildMultipartBody;
+    pollDeployment(deploymentId: string, apiUrl: string, token: string, onStatus?: (status: string, url?: string) => void): Promise<{
+        status: string;
+        url?: string;
+    }>;
+}
+export declare function validateProjectName(name: string): string | null;