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

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;

package/dist/lib/deploy.js

@@ -0,0 +1,181 @@
+import { createHash } from "crypto";
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+import { createGzip } from "zlib";
+import { Readable } from "stream";
+export class DeployHelper {
+    cwd;
+    onProgress;
+    constructor(cwd = process.cwd(), onProgress) {
+        this.cwd = cwd;
+        this.onProgress = onProgress;
+    }
+    report(progress) {
+        if (this.onProgress) {
+            this.onProgress(progress);
+        }
+    }
+    async createZip() {
+        this.report({
+            stage: "zipping",
+            progress: 0,
+            message: "Creating zip archive...",
+        });
+        const files = [];
+        const ignoreDirs = [
+            "node_modules",
+            ".git",
+            ".next",
+            "dist",
+            "build",
+            ".output",
+            ".onflyt",
+            ".venv",
+            "venv",
+            "__pycache__",
+            ".cache",
+            ".turbo",
+            "coverage",
+            ".nyc_output",
+            "target",
+        ];
+        const ignoreFiles = [
+            ".DS_Store",
+            ".gitignore",
+            ".env",
+            ".env.local",
+            ".env.production",
+            "*.log",
+            "npm-debug.log*",
+            "yarn-debug.log*",
+            "yarn-error.log*",
+        ];
+        const walkDir = (dir, basePath = "") => {
+            if (!existsSync(dir))
+                return;
+            const items = readdirSync(dir, { withFileTypes: true });
+            for (const item of items) {
+                const itemPath = join(dir, item.name);
+                const relativePath = basePath ? `${basePath}/${item.name}` : item.name;
+                if (item.isDirectory()) {
+                    if (!ignoreDirs.includes(item.name) && !item.name.startsWith(".")) {
+                        walkDir(itemPath, relativePath);
+                    }
+                }
+                else {
+                    const shouldIgnore = ignoreFiles.some((pattern) => {
+                        if (pattern.startsWith("*")) {
+                            return item.name.endsWith(pattern.slice(1));
+                        }
+                        return item.name === pattern;
+                    });
+                    if (!shouldIgnore) {
+                        try {
+                            const data = readFileSync(itemPath);
+                            files.push({ path: relativePath, data });
+                        }
+                        catch {
+                            // skip files we can't read
+                        }
+                    }
+                }
+            }
+        };
+        walkDir(this.cwd);
+        let content = "";
+        for (const file of files) {
+            content += `${file.path}:${file.data.toString("base64")}\n`;
+        }
+        const zipBuffer = await this.gzip(Buffer.from(content, "utf-8"));
+        this.report({
+            stage: "zipping",
+            progress: 100,
+            message: `Zipped ${files.length} files`,
+        });
+        return zipBuffer;
+    }
+    gzip(data) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            const gzip = createGzip();
+            gzip.on("data", (chunk) => chunks.push(chunk));
+            gzip.on("end", () => resolve(Buffer.concat(chunks)));
+            gzip.on("error", reject);
+            Readable.from(data).pipe(gzip);
+        });
+    }
+    async uploadZip(zipData, projectId, apiUrl, token, onProgress) {
+        this.report({
+            stage: "uploading",
+            progress: 0,
+            message: "Starting upload...",
+        });
+        const boundary = `----FormBoundary${createHash("md5").update(Date.now().toString()).digest("hex")}`;
+        const body = this.buildMultipartBody(zipData, boundary);
+        const totalSize = body.length;
+        const response = await fetch(`${apiUrl}/deployments/${projectId}/upload`, {
+            method: "POST",
+            headers: {
+                "Content-Type": `multipart/form-data; boundary=${boundary}`,
+                Authorization: `Bearer ${token}`,
+            },
+            body: new Uint8Array(body),
+        });
+        const result = await response.json();
+        if (!result.success) {
+            throw new Error(result.error || "Upload failed");
+        }
+        this.report({
+            stage: "uploading",
+            progress: 100,
+            message: "Upload complete",
+        });
+        return { deploymentId: result.deploymentId };
+    }
+    buildMultipartBody(data, boundary) {
+        const parts = [];
+        const header = Buffer.from(`--${boundary}\r\nContent-Type: application/octet-stream\r\nContent-Disposition: form-data; name="file"; filename="source.zip"\r\n\r\n`, "utf-8");
+        const footer = Buffer.from(`\r\n--${boundary}--\r\n`, "utf-8");
+        parts.push(header);
+        parts.push(data);
+        parts.push(footer);
+        return Buffer.concat(parts);
+    }
+    async pollDeployment(deploymentId, apiUrl, token, onStatus) {
+        const maxAttempts = 60;
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+            const response = await fetch(`${apiUrl}/deployments/${deploymentId}`, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            const result = await response.json();
+            if (result.deployment) {
+                const status = result.deployment.status;
+                const url = result.deployment.url;
+                if (onStatus) {
+                    onStatus(status, url);
+                }
+                if (status === "active" ||
+                    status === "deployed" ||
+                    status === "failed") {
+                    return { status, url };
+                }
+            }
+            attempts++;
+        }
+        return { status: "timeout" };
+    }
+}
+export function validateProjectName(name) {
+    if (!name || name.length < 3) {
+        return "Name must be at least 3 characters";
+    }
+    if (name.length > 30) {
+        return "Name must be less than 30 characters";
+    }
+    if (!/^[a-z0-9-]+$/.test(name)) {
+        return "Name must be lowercase alphanumeric with dashes only";
+    }
+    return null;
+}

package/dist/lib/framework.d.ts

@@ -0,0 +1,27 @@
+export interface Framework {
+    id: string;
+    name: string;
+    buildCommand?: string;
+    outputDirectory?: string;
+    installCommand?: string;
+    startCommand?: string;
+}
+export declare const FRAMEWORKS: any;
+export declare const FRAMEWORK_LIST: {
+    id: string;
+    name: any;
+    family: any;
+    isServer: any;
+}[];
+export declare class FrameworkDetector {
+    private cwd;
+    constructor(cwd?: string);
+    detect(): Framework | null;
+    detectOutputDirectory(frameworkId: string): string | null;
+    private toFramework;
+    private hasFile;
+    private readFile;
+    private readPackageJson;
+    getSuggestions(): Framework[];
+}
+export { getFramework } from "./shared";