onflyt-cli 0.1.0-beta

package/src/lib/deploy.ts

@@ -0,0 +1,260 @@
+import { createHash } from "crypto";
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join, basename } from "path";
+import { pipeline } from "stream/promises";
+import { createGzip } from "zlib";
+import { Readable } from "stream";
+
+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 class DeployHelper {
+  private cwd: string;
+  private onProgress?: (progress: DeployProgress) => void;
+
+  constructor(
+    cwd: string = process.cwd(),
+    onProgress?: (p: DeployProgress) => void,
+  ) {
+    this.cwd = cwd;
+    this.onProgress = onProgress;
+  }
+
+  report(progress: DeployProgress) {
+    if (this.onProgress) {
+      this.onProgress(progress);
+    }
+  }
+
+  async createZip(): Promise<Buffer> {
+    this.report({
+      stage: "zipping",
+      progress: 0,
+      message: "Creating zip archive...",
+    });
+
+    const files: { path: string; data: Buffer }[] = [];
+    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: string, basePath: string = "") => {
+      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;
+  }
+
+  private gzip(data: Buffer): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      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: Buffer,
+    projectId: string,
+    apiUrl: string,
+    token: string,
+    onProgress?: (loaded: number, total: number) => void,
+  ): Promise<{ deploymentId: string }> {
+    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 };
+  }
+
+  private buildMultipartBody(data: Buffer, boundary: string): Buffer {
+    const parts: Buffer[] = [];
+
+    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: string,
+    apiUrl: string,
+    token: string,
+    onStatus?: (status: string, url?: string) => void,
+  ): Promise<{ status: string; url?: string }> {
+    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: string): string | null {
+  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/src/lib/framework.ts

@@ -0,0 +1,227 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import {
+  FRAMEWORKS as SHARED_FRAMEWORKS,
+  getFramework,
+  getDefaultOutputDirectory,
+  FrameworkConfig,
+} from "../shared";
+
+export interface Framework {
+  id: string;
+  name: string;
+  buildCommand?: string;
+  outputDirectory?: string;
+  installCommand?: string;
+  startCommand?: string;
+}
+
+export const FRAMEWORKS = SHARED_FRAMEWORKS;
+
+export const FRAMEWORK_LIST = Object.entries(SHARED_FRAMEWORKS).map(
+  ([id, config]) => ({
+    id,
+    name: config.label,
+    family: config.family,
+    isServer: config.isServer,
+  }),
+);
+
+export class FrameworkDetector {
+  private cwd: string;
+
+  constructor(cwd: string = process.cwd()) {
+    this.cwd = cwd;
+  }
+
+  detect(): Framework | null {
+    if (
+      this.hasFile("next.config.js") ||
+      this.hasFile("next.config.mjs") ||
+      this.hasFile("next.config.ts")
+    ) {
+      return this.toFramework("nextjs");
+    }
+
+    if (this.hasFile("nuxt.config.ts") || this.hasFile("nuxt.config.js")) {
+      return this.toFramework("nuxt");
+    }
+
+    if (this.hasFile("package.json")) {
+      const pkg = this.readPackageJson();
+      if (!pkg) return null;
+
+      if (pkg.dependencies?.next || pkg.devDependencies?.next) {
+        return this.toFramework("nextjs");
+      }
+
+      if (pkg.dependencies?.react || pkg.devDependencies?.react) {
+        if (pkg.dependencies?.remix) return this.toFramework("remix");
+        if (pkg.dependencies?.nuxt || pkg.devDependencies?.nuxt)
+          return this.toFramework("nuxt");
+        if (pkg.dependencies?.svelte || pkg.devDependencies?.svelte)
+          return this.toFramework("svelte");
+        if (pkg.dependencies?.angular || pkg.devDependencies?.angular)
+          return this.toFramework("angular");
+        if (pkg.dependencies?.hono || pkg.devDependencies?.hono)
+          return this.toFramework("hono");
+        if (pkg.dependencies?.nestjs || pkg.devDependencies?.nestjs)
+          return this.toFramework("nestjs");
+        return this.toFramework("react");
+      }
+
+      if (pkg.dependencies?.vue || pkg.devDependencies?.vue) {
+        return this.toFramework("vue");
+      }
+
+      if (pkg.dependencies?.express || pkg.devDependencies?.express) {
+        return this.toFramework("express");
+      }
+
+      if (pkg.dependencies?.fastapi || pkg.devDependencies?.fastapi) {
+        return this.toFramework("fastapi");
+      }
+
+      if (pkg.dependencies?.django || pkg.devDependencies?.django) {
+        return this.toFramework("django");
+      }
+
+      if (pkg.dependencies?.flask || pkg.devDependencies?.flask) {
+        return this.toFramework("flask");
+      }
+
+      if (pkg.dependencies?.hono || pkg.devDependencies?.hono) {
+        return this.toFramework("hono");
+      }
+
+      if (pkg.dependencies?.nestjs || pkg.devDependencies?.nestjs) {
+        return this.toFramework("nestjs");
+      }
+
+      if (pkg.scripts?.dev || pkg.scripts?.start) {
+        return this.toFramework("node");
+      }
+    }
+
+    if (this.hasFile("requirements.txt") || this.hasFile("Pipfile")) {
+      const content =
+        this.readFile("requirements.txt") || this.readFile("Pipfile") || "";
+
+      if (content.includes("fastapi")) return this.toFramework("fastapi");
+      if (content.includes("django")) return this.toFramework("django");
+      if (content.includes("flask")) return this.toFramework("flask");
+
+      return this.toFramework("python");
+    }
+
+    if (this.hasFile("go.mod")) {
+      return this.toFramework("go");
+    }
+
+    if (this.hasFile("Cargo.toml")) {
+      return this.toFramework("rust");
+    }
+
+    if (this.hasFile("index.html")) {
+      return this.toFramework("static");
+    }
+
+    if (this.hasFile("Dockerfile")) {
+      return this.toFramework("docker");
+    }
+
+    return null;
+  }
+
+  detectOutputDirectory(frameworkId: string): string | null {
+    const lowerId = frameworkId.toLowerCase();
+
+    if (this.hasFile("package.json")) {
+      const pkg = this.readPackageJson();
+      if (pkg) {
+        const scripts = pkg.scripts || {};
+        if (scripts.build) {
+          if (lowerId === "nextjs") {
+            if (this.hasFile(".next")) return ".next";
+          }
+          if (lowerId === "react" || lowerId === "vue" || lowerId === "vite") {
+            if (this.hasFile("dist")) return "dist";
+            if (this.hasFile("build")) return "build";
+          }
+          if (lowerId === "nuxt") {
+            if (this.hasFile(".output")) return ".output";
+          }
+          if (lowerId === "svelte") {
+            if (this.hasFile("build")) return "build";
+            if (this.hasFile("dist")) return "dist";
+          }
+          if (lowerId === "astro") {
+            if (this.hasFile("dist")) return "dist";
+          }
+        }
+      }
+    }
+
+    return getDefaultOutputDirectory(lowerId) || null;
+  }
+
+  private toFramework(id: string): Framework {
+    const config = SHARED_FRAMEWORKS[id.toLowerCase()];
+    if (!config) {
+      return { id, name: id };
+    }
+    return {
+      id,
+      name: config.label,
+      buildCommand: config.defaults.buildCommand,
+      outputDirectory: config.defaults.outputDirectory,
+      installCommand: config.defaults.installCommand,
+      startCommand: config.defaults.startCommand,
+    };
+  }
+
+  private hasFile(filename: string): boolean {
+    return existsSync(join(this.cwd, filename));
+  }
+
+  private readFile(filename: string): string | null {
+    try {
+      const path = join(this.cwd, filename);
+      if (existsSync(path)) {
+        return readFileSync(path, "utf-8");
+      }
+    } catch {
+      // ignore
+    }
+    return null;
+  }
+
+  private readPackageJson(): {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    scripts?: Record<string, string>;
+  } | null {
+    try {
+      const content = this.readFile("package.json");
+      if (content) {
+        return JSON.parse(content);
+      }
+    } catch {
+      // ignore
+    }
+    return null;
+  }
+
+  getSuggestions(): Framework[] {
+    return Object.entries(SHARED_FRAMEWORKS).map(([id, config]) => ({
+      id,
+      name: config.label,
+      buildCommand: config.defaults.buildCommand,
+      outputDirectory: config.defaults.outputDirectory,
+      installCommand: config.defaults.installCommand,
+      startCommand: config.defaults.startCommand,
+    }));
+  }
+}
+
+export { getFramework } from "../shared";

package/src/lib/git.ts

@@ -0,0 +1,179 @@
+import { execSync } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+
+export interface GitRemote {
+  name: string;
+  url: string;
+  type: "github" | "gitlab" | "other";
+}
+
+export interface GitInfo {
+  isGitRepo: boolean;
+  remotes: GitRemote[];
+  currentBranch: string;
+  rootDir: string;
+}
+
+export class GitDetector {
+  private cwd: string;
+
+  constructor(cwd: string = process.cwd()) {
+    this.cwd = cwd;
+  }
+
+  async detect(): Promise<GitInfo> {
+    try {
+      const isGitRepo = this.isGitRepository();
+      if (!isGitRepo) {
+        return {
+          isGitRepo: false,
+          remotes: [],
+          currentBranch: "",
+          rootDir: this.cwd,
+        };
+      }
+
+      const rootDir = this.getRootDir();
+      const remotes = this.getRemotes();
+      const currentBranch = this.getCurrentBranch();
+
+      return {
+        isGitRepo: true,
+        remotes,
+        currentBranch,
+        rootDir,
+      };
+    } catch {
+      return {
+        isGitRepo: false,
+        remotes: [],
+        currentBranch: "",
+        rootDir: this.cwd,
+      };
+    }
+  }
+
+  private isGitRepository(): boolean {
+    try {
+      execSync("git rev-parse --git-dir", {
+        cwd: this.cwd,
+        stdio: "ignore",
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private getRootDir(): string {
+    try {
+      const root = execSync("git rev-parse --show-toplevel", {
+        cwd: this.cwd,
+        encoding: "utf-8",
+      }).trim();
+      return root;
+    } catch {
+      return this.cwd;
+    }
+  }
+
+  private getCurrentBranch(): string {
+    try {
+      const branch = execSync("git branch --show-current", {
+        cwd: this.cwd,
+        encoding: "utf-8",
+      }).trim();
+      return branch;
+    } catch {
+      return "";
+    }
+  }
+
+  private getRemotes(): GitRemote[] {
+    try {
+      const output = execSync("git remote -v", {
+        cwd: this.cwd,
+        encoding: "utf-8",
+      });
+
+      const remotes: GitRemote[] = [];
+      const lines = output.trim().split("\n");
+
+      for (const line of lines) {
+        const match = line.match(/^(\S+)\s+(\S+)\s+\((\w+)\)$/);
+        if (match) {
+          const [, name, url] = match;
+          const type = this.detectRemoteType(url);
+          if (!remotes.find((r) => r.name === name)) {
+            remotes.push({ name, url, type });
+          }
+        }
+      }
+
+      return remotes;
+    } catch {
+      return [];
+    }
+  }
+
+  private detectRemoteType(url: string): "github" | "gitlab" | "other" {
+    if (url.includes("github.com")) return "github";
+    if (url.includes("gitlab.com")) return "gitlab";
+    return "other";
+  }
+
+  async getBranches(): Promise<string[]> {
+    try {
+      const output = execSync("git branch -a", {
+        cwd: this.cwd,
+        encoding: "utf-8",
+      });
+
+      return output
+        .trim()
+        .split("\n")
+        .map((b) => b.replace(/^\*?\s*/, "").trim())
+        .filter(
+          (b) =>
+            (b && !b.startsWith("remotes/")) || b.startsWith("remotes/origin/"),
+        )
+        .map((b) => b.replace(/^remotes\/origin\//, ""));
+    } catch {
+      return [];
+    }
+  }
+
+  async getRepoId(): Promise<number | null> {
+    try {
+      const output = execSync("git remote get-url origin", {
+        cwd: this.cwd,
+        encoding: "utf-8",
+      }).trim();
+
+      const match = output.match(/git@github\.com:(\d+)\//);
+      if (match) {
+        return parseInt(match[1], 10);
+      }
+
+      const urlMatch = output.match(/github\.com\/[^\/]+\/([^\/\.]+)/);
+      if (urlMatch) {
+        return null;
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  static getProjectNameFromRepo(repoUrl: string): string {
+    const match = repoUrl.match(/\/([^\/]+?)(?:\.git)?$/);
+    return match ? match[1] : "";
+  }
+
+  static getOwnerFromRepo(repoUrl: string): string {
+    const match = repoUrl.match(/github\.com\/([^\/]+)\//);
+    return match ? match[1] : "";
+  }
+}