quicklify 0.1.0

package/src/types/index.ts

@@ -0,0 +1,36 @@
+export interface Region {
+  id: string;
+  name: string;
+  location: string;
+}
+
+export interface ServerSize {
+  id: string;
+  name: string;
+  vcpu: number;
+  ram: number;
+  disk: number;
+  price: string;
+  recommended?: boolean;
+}
+
+export interface ServerConfig {
+  name: string;
+  size: string;
+  region: string;
+  cloudInit: string;
+}
+
+export interface ServerResult {
+  id: string;
+  ip: string;
+  status: string;
+}
+
+export interface DeploymentConfig {
+  provider: string;
+  apiToken: string;
+  region: string;
+  serverSize: string;
+  serverName: string;
+}

package/src/utils/cloudInit.ts

@@ -0,0 +1,29 @@
+export function getCoolifyCloudInit(serverName: string): string {
+  return `#!/bin/bash
+set -e
+
+echo "=================================="
+echo "Quicklify Auto-Installer"
+echo "Server: ${serverName}"
+echo "=================================="
+
+# Update system
+echo "Updating system packages..."
+apt-get update -y
+
+# Install Coolify
+echo "Installing Coolify..."
+curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
+
+# Wait for services
+echo "Waiting for Coolify services to start..."
+sleep 30
+
+echo "=================================="
+echo "Coolify installation completed!"
+echo "=================================="
+echo ""
+echo "Please wait 2-3 more minutes for Coolify to fully initialize."
+echo "Then access your instance at: https://YOUR_SERVER_IP:8000"
+`;
+}

package/src/utils/logger.ts

@@ -0,0 +1,37 @@
+import chalk from "chalk";
+import ora, { type Ora } from "ora";
+
+export const logger = {
+  info: (message: string) => {
+    console.log(chalk.blue("ℹ"), message);
+  },
+
+  success: (message: string) => {
+    console.log(chalk.green("✔"), message);
+  },
+
+  error: (message: string) => {
+    console.log(chalk.red("✖"), message);
+  },
+
+  warning: (message: string) => {
+    console.log(chalk.yellow("⚠"), message);
+  },
+
+  title: (message: string) => {
+    console.log();
+    console.log(chalk.bold.cyan(message));
+    console.log();
+  },
+
+  step: (message: string) => {
+    console.log(chalk.gray("→"), message);
+  },
+};
+
+export function createSpinner(text: string): Ora {
+  return ora({
+    text,
+    color: "cyan",
+  });
+}

package/src/utils/prompts.ts

@@ -0,0 +1,84 @@
+import inquirer from "inquirer";
+import type { CloudProvider } from "../providers/base.js";
+import type { DeploymentConfig } from "../types/index.js";
+
+export async function getDeploymentConfig(provider: CloudProvider): Promise<DeploymentConfig> {
+  const answers = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiToken",
+      message: `Enter your ${provider.displayName} API token:`,
+      validate: (input: string) => {
+        if (!input || input.trim().length === 0) {
+          return "API token is required";
+        }
+        return true;
+      },
+    },
+    {
+      type: "list",
+      name: "region",
+      message: "Select region:",
+      choices: provider.getRegions().map((r) => ({
+        name: `${r.name} (${r.location})`,
+        value: r.id,
+      })),
+    },
+    {
+      type: "list",
+      name: "size",
+      message: "Select server size:",
+      choices: provider.getServerSizes().map((s) => ({
+        name: `${s.name} - ${s.vcpu} vCPU, ${s.ram}GB RAM - ${s.price}${s.recommended ? " ⭐ Recommended" : ""}`,
+        value: s.id,
+      })),
+    },
+    {
+      type: "input",
+      name: "serverName",
+      message: "Server name:",
+      default: "coolify-server",
+      validate: (input: string) => {
+        if (!input || input.trim().length === 0) {
+          return "Server name is required";
+        }
+        if (!/^[a-z0-9-]+$/.test(input)) {
+          return "Server name must contain only lowercase letters, numbers, and hyphens";
+        }
+        return true;
+      },
+    },
+  ]);
+
+  return {
+    provider: provider.name,
+    apiToken: answers.apiToken.trim(),
+    region: answers.region,
+    serverSize: answers.size,
+    serverName: answers.serverName.trim(),
+  };
+}
+
+export async function confirmDeployment(config: DeploymentConfig, provider: CloudProvider): Promise<boolean> {
+  const region = provider.getRegions().find((r) => r.id === config.region);
+  const size = provider.getServerSizes().find((s) => s.id === config.serverSize);
+
+  console.log("\nDeployment Summary:");
+  console.log(`  Provider: ${provider.displayName}`);
+  console.log(`  Region: ${region?.name} (${region?.location})`);
+  console.log(`  Size: ${size?.name} - ${size?.vcpu} vCPU, ${size?.ram}GB RAM`);
+  console.log(`  Price: ${size?.price}`);
+  console.log(`  Server Name: ${config.serverName}`);
+  console.log();
+
+  const { confirm } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "Proceed with deployment?",
+      default: true,
+    },
+  ]);
+
+  return confirm;
+}

package/tests/__mocks__/axios.ts

@@ -0,0 +1,14 @@
+const axios = {
+  get: jest.fn(),
+  post: jest.fn(),
+  put: jest.fn(),
+  delete: jest.fn(),
+  patch: jest.fn(),
+  defaults: {
+    headers: {
+      common: {},
+    },
+  },
+};
+
+export default axios;

package/tests/__mocks__/chalk.ts

@@ -0,0 +1,15 @@
+const identity = (s: string) => s;
+
+const bold = Object.assign(identity, { cyan: identity });
+
+const chalk = {
+  blue: identity,
+  green: identity,
+  red: identity,
+  yellow: identity,
+  gray: identity,
+  cyan: identity,
+  bold,
+};
+
+export default chalk;

package/tests/__mocks__/inquirer.ts

@@ -0,0 +1,5 @@
+const inquirer = {
+  prompt: jest.fn(),
+};
+
+export default inquirer;

package/tests/__mocks__/ora.ts

@@ -0,0 +1,16 @@
+const createMockSpinner = () => {
+  const spinner: any = {
+    text: '',
+    color: 'cyan',
+  };
+  spinner.start = jest.fn(() => spinner);
+  spinner.succeed = jest.fn(() => spinner);
+  spinner.fail = jest.fn(() => spinner);
+  spinner.stop = jest.fn(() => spinner);
+  return spinner;
+};
+
+const ora = jest.fn(() => createMockSpinner());
+
+export default ora;
+export { createMockSpinner };

package/tests/e2e/init.test.ts

@@ -0,0 +1,190 @@
+import axios from 'axios';
+import inquirer from 'inquirer';
+import { initCommand } from '../../src/commands/init';
+
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+const mockedInquirer = inquirer as jest.Mocked<typeof inquirer>;
+
+describe('initCommand E2E', () => {
+  let consoleSpy: jest.SpyInstance;
+  let processExitSpy: jest.SpyInstance;
+  const originalSetTimeout = global.setTimeout;
+
+  beforeEach(() => {
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    processExitSpy = jest.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+    jest.clearAllMocks();
+
+    // Make all setTimeout calls resolve instantly for test speed
+    global.setTimeout = ((fn: Function) => {
+      fn();
+      return 0;
+    }) as any;
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    processExitSpy.mockRestore();
+    global.setTimeout = originalSetTimeout;
+  });
+
+  it('should complete full deployment flow successfully', async () => {
+    // Mock: user fills config + confirms
+    mockedInquirer.prompt
+      .mockResolvedValueOnce({
+        apiToken: 'valid-token',
+        region: 'nbg1',
+        size: 'cax11',
+        serverName: 'coolify-test',
+      })
+      .mockResolvedValueOnce({ confirm: true });
+
+    // Mock: validateToken succeeds
+    mockedAxios.get
+      .mockResolvedValueOnce({ data: { servers: [] } })
+      // Mock: getServerStatus returns running immediately
+      .mockResolvedValueOnce({ data: { server: { status: 'running' } } });
+
+    // Mock: createServer succeeds
+    mockedAxios.post.mockResolvedValueOnce({
+      data: {
+        server: {
+          id: 123,
+          public_net: { ipv4: { ip: '1.2.3.4' } },
+          status: 'initializing',
+        },
+      },
+    });
+
+    await initCommand();
+
+    // Verify API calls were made
+    expect(mockedAxios.get).toHaveBeenCalled();
+    expect(mockedAxios.post).toHaveBeenCalled();
+
+    // Verify success output contains IP
+    const allOutput = consoleSpy.mock.calls.map((c: any[]) => c.join(' ')).join('\n');
+    expect(allOutput).toContain('1.2.3.4');
+
+    // Verify process.exit was NOT called (success path)
+    expect(processExitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should abort when user cancels deployment', async () => {
+    mockedInquirer.prompt
+      .mockResolvedValueOnce({
+        apiToken: 'valid-token',
+        region: 'nbg1',
+        size: 'cax11',
+        serverName: 'coolify-test',
+      })
+      .mockResolvedValueOnce({ confirm: false });
+
+    await initCommand();
+
+    // No API calls should be made after cancellation
+    expect(mockedAxios.get).not.toHaveBeenCalled();
+    expect(mockedAxios.post).not.toHaveBeenCalled();
+  });
+
+  it('should stop on invalid API token', async () => {
+    mockedInquirer.prompt
+      .mockResolvedValueOnce({
+        apiToken: 'bad-token',
+        region: 'nbg1',
+        size: 'cax11',
+        serverName: 'coolify-test',
+      })
+      .mockResolvedValueOnce({ confirm: true });
+
+    // Mock: validateToken fails
+    mockedAxios.get.mockRejectedValueOnce(new Error('Unauthorized'));
+
+    await initCommand();
+
+    // createServer should never be called
+    expect(mockedAxios.post).not.toHaveBeenCalled();
+    expect(processExitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should handle server creation failure', async () => {
+    mockedInquirer.prompt
+      .mockResolvedValueOnce({
+        apiToken: 'valid-token',
+        region: 'nbg1',
+        size: 'cax11',
+        serverName: 'coolify-test',
+      })
+      .mockResolvedValueOnce({ confirm: true });
+
+    // Mock: validateToken succeeds
+    mockedAxios.get.mockResolvedValueOnce({ data: { servers: [] } });
+
+    // Mock: createServer fails
+    mockedAxios.post.mockRejectedValueOnce({
+      response: { data: { error: { message: 'insufficient_funds' } } },
+    });
+
+    await initCommand();
+
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('should handle server boot timeout', async () => {
+    mockedInquirer.prompt
+      .mockResolvedValueOnce({
+        apiToken: 'valid-token',
+        region: 'nbg1',
+        size: 'cax11',
+        serverName: 'coolify-test',
+      })
+      .mockResolvedValueOnce({ confirm: true });
+
+    // Mock: validateToken succeeds
+    mockedAxios.get
+      .mockResolvedValueOnce({ data: { servers: [] } });
+
+    // Mock: createServer succeeds
+    mockedAxios.post.mockResolvedValueOnce({
+      data: {
+        server: {
+          id: 456,
+          public_net: { ipv4: { ip: '5.6.7.8' } },
+          status: 'initializing',
+        },
+      },
+    });
+
+    // Mock: getServerStatus always returns 'initializing' (never reaches 'running')
+    mockedAxios.get.mockResolvedValue({
+      data: { server: { status: 'initializing' } },
+    });
+
+    await initCommand();
+
+    // Should NOT call process.exit (it returns early, not throws)
+    // Server creation was attempted
+    expect(mockedAxios.post).toHaveBeenCalled();
+  });
+
+  it('should handle network error during deployment', async () => {
+    mockedInquirer.prompt
+      .mockResolvedValueOnce({
+        apiToken: 'valid-token',
+        region: 'nbg1',
+        size: 'cax11',
+        serverName: 'coolify-test',
+      })
+      .mockResolvedValueOnce({ confirm: true });
+
+    // Mock: validateToken succeeds
+    mockedAxios.get.mockResolvedValueOnce({ data: { servers: [] } });
+
+    // Mock: createServer network error
+    mockedAxios.post.mockRejectedValueOnce(new Error('ECONNREFUSED'));
+
+    await initCommand();
+
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+});