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

package/src/index.tsx

@@ -0,0 +1,130 @@
+import React from "react";
+import { Text, Box } from "ink";
+import meow from "meow";
+import Help from "./commands/help.js";
+import Login from "./commands/login.js";
+import Logout from "./commands/logout.js";
+import WhoAmI from "./commands/whoami.js";
+import ProjectsList from "./commands/projects.js";
+import Init from "./commands/init.js";
+import Credits from "./commands/credits.js";
+import Teams from "./commands/teams.js";
+import Deploy from "./commands/deploy.js";
+import Logs from "./commands/logs.js";
+import Deployments from "./commands/deployments.js";
+import Delete from "./commands/delete.js";
+import Rollback from "./commands/rollback.js";
+
+const cli = meow(
+  `
+  Onflyt CLI v1.0.1-beta.1
+
+  Usage
+    $ onflyt <command>
+
+  Commands
+    login              Authenticate with Onflyt
+    init               Initialize a new project
+    deploy             Deploy your project
+    projects           Manage projects
+    teams              List your teams
+    logs               View deployment logs
+    deployments        List project deployments
+    delete             Delete a project
+    rollback           Rollback to previous deployment
+    whoami             Show current user
+    logout             Sign out
+    credits            Check credits balance
+
+  Init Options
+    --name <name>      Project name
+    --template <id>    Template ID (blank, nextjs, react-vite, etc.)
+    --framework <fw>   Framework (nextjs, react, node, etc.)
+    --package-manager  Package manager (npm, bun, yarn, pnpm)
+    --git / --no-git   Connect or skip git
+    --yes              Skip all prompts (use defaults)
+
+  Logs Options
+    --live, -l         Stream live logs (SSE)
+
+  Options
+    --version, -v      Show CLI version
+    --help, -h         Show this help
+    --debug            Enable debug mode
+    --no-open          Don't open browser automatically
+`,
+  {
+    importMeta: import.meta,
+    autoHelp: false,
+    flags: {
+      version: { type: "boolean", shortFlag: "v" },
+      help: { type: "boolean", shortFlag: "h" },
+      team: { type: "string", shortFlag: "t" },
+      noOpen: { type: "boolean" },
+      name: { type: "string" },
+      template: { type: "string" },
+      framework: { type: "string" },
+      packageManager: { type: "string" },
+      git: { type: "boolean" },
+      yes: { type: "boolean", shortFlag: "y" },
+      live: { type: "boolean", shortFlag: "l" },
+    },
+  },
+);
+
+if (
+  cli.flags.help ||
+  cli.input[0] === "help" ||
+  cli.input[0] === "--help" ||
+  cli.input[0] === "-h"
+) {
+  render(<Help />, { exitOnCtrlC: false });
+  process.exit(0);
+}
+
+import { render } from "ink";
+import App from "./App.js";
+
+const command = cli.input[0];
+
+const CommandRouter = () => {
+  switch (command) {
+    case "login":
+      return <Login openBrowser={!cli.flags.noOpen} />;
+    case "logout":
+      return <Logout />;
+    case "whoami":
+      return <WhoAmI />;
+    case "projects":
+      return <ProjectsList />;
+    case "init":
+      return (
+        <Init
+          name={cli.flags.name}
+          template={cli.flags.template}
+          framework={cli.flags.framework}
+          packageManager={cli.flags.packageManager}
+          git={cli.flags.git}
+          yes={cli.flags.yes}
+        />
+      );
+    case "credits":
+      return <Credits />;
+    case "teams":
+      return <Teams />;
+    case "deploy":
+      return <Deploy teamFlag={cli.flags.team} />;
+    case "logs":
+      return <Logs deploymentId={cli.input[1]} live={cli.flags.live} />;
+    case "deployments":
+      return <Deployments projectName={cli.input[1]} />;
+    case "delete":
+      return <Delete projectId={cli.input[1]} />;
+    case "rollback":
+      return <Rollback deploymentId={cli.input[1]} />;
+    default:
+      return <App />;
+  }
+};
+
+render(<CommandRouter />, { exitOnCtrlC: false });

package/src/lib/api.ts

@@ -0,0 +1,152 @@
+import { API_URL, getConfig } from "./config.js";
+
+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 class ApiClient {
+  private token: string | null;
+
+  constructor() {
+    const config = getConfig();
+    this.token = config.token || null;
+  }
+
+  setToken(token: string) {
+    this.token = token;
+  }
+
+  private async request<T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      ...((options.headers as Record<string, string>) || {}),
+    };
+
+    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 {} as T;
+    }
+
+    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 as any;
+    }
+  }
+
+  async get<T>(endpoint: string): Promise<T> {
+    return this.request<T>(endpoint, { method: "GET" });
+  }
+
+  async post<T>(endpoint: string, body?: unknown): Promise<T> {
+    return this.request<T>(endpoint, {
+      method: "POST",
+      body: body ? JSON.stringify(body) : undefined,
+    });
+  }
+
+  async patch<T>(endpoint: string, body?: unknown): Promise<T> {
+    return this.request<T>(endpoint, {
+      method: "PATCH",
+      body: body ? JSON.stringify(body) : undefined,
+    });
+  }
+
+  async delete<T>(endpoint: string): Promise<T> {
+    return this.request<T>(endpoint, { method: "DELETE" });
+  }
+
+  async uploadFile<T>(
+    endpoint: string,
+    filePath: string,
+    filename: string,
+    onProgress?: (uploaded: number, total: number) => void,
+  ): Promise<T> {
+    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 as any;
+    }
+  }
+}
+
+export class ApiException extends Error {
+  constructor(
+    message: string,
+    public status: number,
+    public code?: string,
+  ) {
+    super(message);
+    this.name = "ApiException";
+  }
+}
+
+export const api = new ApiClient();

package/src/lib/config.ts

@@ -0,0 +1,90 @@
+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 interface Config {
+  token?: string;
+  user?: {
+    id: string;
+    email: string;
+    name: string;
+    avatar?: string;
+  };
+  defaultTeam?: string;
+  lastLogin?: string;
+}
+
+export function getConfig(): Config {
+  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: Config): void {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export function clearConfig(): void {
+  if (existsSync(CONFIG_FILE)) {
+    const config = getConfig();
+    saveConfig({});
+  }
+}
+
+export function isLoggedIn(): boolean {
+  const config = getConfig();
+  return !!config.token;
+}
+
+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 function getProjectConfig(
+  cwd: string = process.cwd(),
+): ProjectConfig | null {
+  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: ProjectConfig,
+  cwd: string = process.cwd(),
+): void {
+  const configPath = join(cwd, PROJECT_CONFIG_FILE);
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+export function hasProjectConfig(cwd: string = process.cwd()): boolean {
+  const configPath = join(cwd, PROJECT_CONFIG_FILE);
+  return existsSync(configPath);
+}