gazill 1.0.0 → 1.0.1

package/src/commands/login.ts

@@ -1,90 +0,0 @@
-import inquirer from 'inquirer';
-import chalk from 'chalk';
-import ora from 'ora';
-import { signin, signup } from '../lib/api.js';
-import { saveAuth, isAuthenticated, getAuth } from '../lib/config.js';
-
-export async function loginCommand(): Promise<void> {
-  // Check if already authenticated
-  if (await isAuthenticated()) {
-    const auth = await getAuth();
-    console.log(chalk.yellow(`Already logged in as ${auth?.email}`));
-    console.log(chalk.gray('Run "gazill logout" to switch accounts.'));
-    return;
-  }
-
-  // Ask for action
-  const { action } = await inquirer.prompt<{ action: 'signin' | 'signup' }>([
-    {
-      type: 'list',
-      name: 'action',
-      message: 'What would you like to do?',
-      choices: [
-        { name: 'Sign in to existing account', value: 'signin' },
-        { name: 'Create a new account', value: 'signup' },
-      ],
-    },
-  ]);
-
-  // Get credentials
-  const { email, password } = await inquirer.prompt<{
-    email: string;
-    password: string;
-  }>([
-    {
-      type: 'input',
-      name: 'email',
-      message: 'Email:',
-      validate: (input: string) => {
-        if (!input || !input.includes('@')) {
-          return 'Please enter a valid email address';
-        }
-        return true;
-      },
-    },
-    {
-      type: 'password',
-      name: 'password',
-      message: 'Password:',
-      mask: '*',
-      validate: (input: string) => {
-        if (!input || input.length < 8) {
-          return 'Password must be at least 8 characters';
-        }
-        return true;
-      },
-    },
-  ]);
-
-  const spinner = ora(
-    action === 'signup' ? 'Creating account...' : 'Signing in...'
-  ).start();
-
-  try {
-    const response =
-      action === 'signup'
-        ? await signup(email, password)
-        : await signin(email, password);
-
-    // Save auth token
-    await saveAuth({
-      token: response.token,
-      email: response.user.email,
-    });
-
-    spinner.succeed(
-      chalk.green(
-        action === 'signup'
-          ? 'Account created successfully!'
-          : 'Signed in successfully!'
-      )
-    );
-
-    console.log(chalk.blue(`\nWelcome, ${response.user.email}!`));
-    console.log(chalk.gray('Run "gazill new <project-name>" to create a project.'));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Authentication failed';
-    spinner.fail(chalk.red(message));
-    process.exit(1);
-  }
-}

package/src/commands/logout.ts

@@ -1,15 +0,0 @@
-import chalk from 'chalk';
-import { clearAuth, isAuthenticated, getAuth } from '../lib/config.js';
-
-export async function logoutCommand(): Promise<void> {
-  if (!(await isAuthenticated())) {
-    console.log(chalk.yellow('You are not logged in.'));
-    return;
-  }
-
-  const auth = await getAuth();
-  await clearAuth();
-
-  console.log(chalk.green(`Logged out successfully.`));
-  console.log(chalk.gray(`Goodbye, ${auth?.email}!`));
-}

package/src/commands/logs.ts

@@ -1,90 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import ora from 'ora';
-import { listProjects, getLogs } from '../lib/api.js';
-import { isAuthenticated } from '../lib/config.js';
-
-export async function logsCommand(nameOrId?: string): Promise<void> {
-  // Check authentication
-  if (!(await isAuthenticated())) {
-    console.log(chalk.red('Please log in first.'));
-    console.log(chalk.gray('Run "gazill login" to authenticate.'));
-    process.exit(1);
-  }
-
-  let projectId: string | undefined;
-  let projectName: string | undefined;
-
-  // If no name provided, try to get from current directory
-  if (!nameOrId) {
-    const projectConfigPath = path.join(process.cwd(), '.gazill', 'project.json');
-    try {
-      const configContent = await fs.readFile(projectConfigPath, 'utf-8');
-      const projectConfig = JSON.parse(configContent) as {
-        id: string;
-        name: string;
-      };
-      projectId = projectConfig.id;
-      projectName = projectConfig.name;
-    } catch {
-      console.log(chalk.red('No project specified.'));
-      console.log(
-        chalk.gray('Run "gazill logs <project-name>" or run from a project directory.')
-      );
-      process.exit(1);
-    }
-  } else {
-    // Find project by name or ID
-    const spinner = ora('Finding project...').start();
-    try {
-      const { projects } = await listProjects();
-      const project = projects.find(
-        (p) => p.name === nameOrId || p.id === nameOrId
-      );
-
-      if (!project) {
-        spinner.fail(chalk.red(`Project "${nameOrId}" not found.`));
-        process.exit(1);
-      }
-
-      projectId = project.id;
-      projectName = project.name;
-      spinner.stop();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : 'Failed to find project';
-      spinner.fail(chalk.red(message));
-      process.exit(1);
-    }
-  }
-
-  // Fetch logs
-  const spinner = ora(`Fetching logs for ${projectName}...`).start();
-
-  try {
-    const { logs } = await getLogs(projectId, 100);
-
-    spinner.stop();
-
-    if (logs.length === 0) {
-      console.log(chalk.yellow('No logs available.'));
-      console.log(
-        chalk.gray('The container may not have started yet or has no output.')
-      );
-      return;
-    }
-
-    console.log(chalk.bold(`\nLogs for ${projectName}:\n`));
-    console.log(chalk.gray('-'.repeat(60)));
-
-    for (const entry of logs) {
-      console.log(entry.message);
-    }
-
-    console.log(chalk.gray('-'.repeat(60)));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Failed to fetch logs';
-    spinner.fail(chalk.red(message));
-    process.exit(1);
-  }
-}

package/src/commands/new.ts

@@ -1,162 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import ora from 'ora';
-import { projectNameSchema, BASE_DOMAIN } from '@gazill/shared';
-import { createProject } from '../lib/api.js';
-import { isAuthenticated } from '../lib/config.js';
-import { startWatcher } from '../lib/watcher.js';
-
-// Starter files for a basic Node.js project
-const STARTER_FILES = {
-  'package.json': JSON.stringify(
-    {
-      name: '{{PROJECT_NAME}}',
-      version: '1.0.0',
-      scripts: {
-        start: 'node index.js',
-      },
-    },
-    null,
-    2
-  ),
-  'index.js': `const http = require('http');
-
-const port = process.env.PORT || 3000;
-
-const server = http.createServer((req, res) => {
-  res.writeHead(200, { 'Content-Type': 'text/html' });
-  res.end('<h1>Hello from Gazill!</h1><p>Edit index.js and save to see changes.</p>');
-});
-
-server.listen(port, () => {
-  console.log(\`Server running on port \${port}\`);
-});
-`,
-};
-
-export async function newCommand(name: string): Promise<void> {
-  // Check authentication
-  if (!(await isAuthenticated())) {
-    console.log(chalk.red('Please log in first.'));
-    console.log(chalk.gray('Run "gazill login" to authenticate.'));
-    process.exit(1);
-  }
-
-  // Validate project name
-  try {
-    projectNameSchema.parse(name);
-  } catch {
-    console.log(chalk.red('Invalid project name.'));
-    console.log(
-      chalk.gray(
-        'Project names must be 3-63 characters, lowercase alphanumeric with hyphens.'
-      )
-    );
-    console.log(chalk.gray('Example: my-awesome-app'));
-    process.exit(1);
-  }
-
-  // Check if directory already exists
-  const projectDir = path.resolve(process.cwd(), name);
-  try {
-    await fs.access(projectDir);
-    console.log(chalk.red(`Directory "${name}" already exists.`));
-    process.exit(1);
-  } catch {
-    // Directory doesn't exist, good to proceed
-  }
-
-  // Create project via API
-  const spinner = ora('Creating project...').start();
-
-  try {
-    const { project, url } = await createProject(name);
-
-    // Create local directory
-    await fs.mkdir(projectDir, { recursive: true });
-
-    // Create starter files
-    for (const [filename, content] of Object.entries(STARTER_FILES)) {
-      const fileContent = content.replace('{{PROJECT_NAME}}', name);
-      await fs.writeFile(path.join(projectDir, filename), fileContent, 'utf-8');
-    }
-
-    // Create .gazill directory with project config
-    const gazillDir = path.join(projectDir, '.gazill');
-    await fs.mkdir(gazillDir, { recursive: true });
-    await fs.writeFile(
-      path.join(gazillDir, 'project.json'),
-      JSON.stringify(
-        {
-          id: project.id,
-          name: project.name,
-          subdomain: project.subdomain,
-        },
-        null,
-        2
-      ),
-      'utf-8'
-    );
-
-    spinner.succeed(chalk.green('Project created!'));
-
-    console.log('');
-    console.log(chalk.blue('Project:'), name);
-    console.log(chalk.blue('URL:'), chalk.underline(url));
-    console.log('');
-    console.log(chalk.gray('Starting file watcher...'));
-    console.log('');
-
-    // Change to project directory and start watcher
-    process.chdir(projectDir);
-
-    await startWatcher({
-      projectId: project.id,
-      projectDir,
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Failed to create project';
-    spinner.fail(chalk.red(message));
-    process.exit(1);
-  }
-}
-
-// Watch an existing project
-export async function watchCommand(): Promise<void> {
-  // Check authentication
-  if (!(await isAuthenticated())) {
-    console.log(chalk.red('Please log in first.'));
-    console.log(chalk.gray('Run "gazill login" to authenticate.'));
-    process.exit(1);
-  }
-
-  const projectDir = process.cwd();
-  const projectConfigPath = path.join(projectDir, '.gazill', 'project.json');
-
-  // Check if this is a Gazill project
-  try {
-    const configContent = await fs.readFile(projectConfigPath, 'utf-8');
-    const projectConfig = JSON.parse(configContent) as {
-      id: string;
-      name: string;
-      subdomain: string;
-    };
-
-    console.log(chalk.blue('Project:'), projectConfig.name);
-    console.log(
-      chalk.blue('URL:'),
-      chalk.underline(`https://${projectConfig.subdomain}.${BASE_DOMAIN}`)
-    );
-    console.log('');
-
-    await startWatcher({
-      projectId: projectConfig.id,
-      projectDir,
-    });
-  } catch {
-    console.log(chalk.red('Not a Gazill project.'));
-    console.log(chalk.gray('Run "gazill new <name>" to create a new project.'));
-    process.exit(1);
-  }
-}

package/src/commands/status.ts

@@ -1,70 +0,0 @@
-import chalk from 'chalk';
-import ora from 'ora';
-import { BASE_DOMAIN } from '@gazill/shared';
-import { listProjects } from '../lib/api.js';
-import { isAuthenticated } from '../lib/config.js';
-
-const STATUS_COLORS: Record<string, (text: string) => string> = {
-  pending: chalk.yellow,
-  building: chalk.blue,
-  running: chalk.green,
-  stopped: chalk.gray,
-  error: chalk.red,
-};
-
-export async function statusCommand(): Promise<void> {
-  // Check authentication
-  if (!(await isAuthenticated())) {
-    console.log(chalk.red('Please log in first.'));
-    console.log(chalk.gray('Run "gazill login" to authenticate.'));
-    process.exit(1);
-  }
-
-  const spinner = ora('Fetching projects...').start();
-
-  try {
-    const { projects } = await listProjects();
-
-    if (projects.length === 0) {
-      spinner.info('No projects found.');
-      console.log(chalk.gray('\nRun "gazill new <name>" to create a project.'));
-      return;
-    }
-
-    spinner.stop();
-
-    console.log(chalk.bold('\nYour Projects:\n'));
-
-    // Calculate column widths
-    const nameWidth = Math.max(...projects.map((p) => p.name.length), 4);
-    const statusWidth = 8;
-    const urlWidth = Math.max(
-      ...projects.map((p) => `${p.subdomain}.${BASE_DOMAIN}`.length),
-      3
-    );
-
-    // Header
-    console.log(
-      chalk.gray(
-        `${'NAME'.padEnd(nameWidth)}  ${'STATUS'.padEnd(statusWidth)}  ${'URL'.padEnd(urlWidth)}`
-      )
-    );
-    console.log(chalk.gray('-'.repeat(nameWidth + statusWidth + urlWidth + 4)));
-
-    // Projects
-    for (const project of projects) {
-      const colorFn = STATUS_COLORS[project.status] || chalk.white;
-      const url = `${project.subdomain}.${BASE_DOMAIN}`;
-
-      console.log(
-        `${project.name.padEnd(nameWidth)}  ${colorFn(project.status.padEnd(statusWidth))}  ${chalk.underline(url)}`
-      );
-    }
-
-    console.log('');
-  } catch (error) {
-    const message = error instanceof Error ? error.message : 'Failed to fetch projects';
-    spinner.fail(chalk.red(message));
-    process.exit(1);
-  }
-}

package/src/index.ts

@@ -1,48 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import { loginCommand } from './commands/login.js';
-import { logoutCommand } from './commands/logout.js';
-import { newCommand, watchCommand } from './commands/new.js';
-import { statusCommand } from './commands/status.js';
-import { logsCommand } from './commands/logs.js';
-
-const program = new Command();
-
-program
-  .name('gazill')
-  .description('Auto-deploy platform for developers')
-  .version('1.0.0');
-
-program
-  .command('login')
-  .description('Authenticate with Gazill')
-  .action(loginCommand);
-
-program
-  .command('logout')
-  .description('Log out from Gazill')
-  .action(logoutCommand);
-
-program
-  .command('new <name>')
-  .description('Create a new project and start watching for changes')
-  .action(newCommand);
-
-program
-  .command('watch')
-  .description('Watch the current project for changes')
-  .action(watchCommand);
-
-program
-  .command('status')
-  .alias('ls')
-  .description('List all your projects')
-  .action(statusCommand);
-
-program
-  .command('logs [name]')
-  .description('View logs for a project')
-  .action(logsCommand);
-
-program.parse();

package/src/lib/api.ts

@@ -1,104 +0,0 @@
-import type {
-  AuthResponse,
-  CreateProjectResponse,
-  ProjectListResponse,
-  DeployResponse,
-  LogsResponse,
-  ApiError,
-  DeployFile,
-} from '@gazill/shared';
-import { getApiUrl, getAuth } from './config.js';
-
-interface RequestOptions {
-  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
-  body?: unknown;
-  auth?: boolean;
-}
-
-async function request<T>(endpoint: string, options: RequestOptions): Promise<T> {
-  const apiUrl = await getApiUrl();
-  const url = `${apiUrl}${endpoint}`;
-
-  const headers: Record<string, string> = {
-    'Content-Type': 'application/json',
-  };
-
-  if (options.auth !== false) {
-    const auth = await getAuth();
-    if (auth?.token) {
-      headers['Authorization'] = `Bearer ${auth.token}`;
-    }
-  }
-
-  const response = await fetch(url, {
-    method: options.method,
-    headers,
-    body: options.body ? JSON.stringify(options.body) : undefined,
-  });
-
-  const data = await response.json();
-
-  if (!response.ok) {
-    const error = data as ApiError;
-    throw new Error(error.message || 'Request failed');
-  }
-
-  return data as T;
-}
-
-// Auth API
-export async function signup(email: string, password: string): Promise<AuthResponse> {
-  return request<AuthResponse>('/api/auth/signup', {
-    method: 'POST',
-    body: { email, password },
-    auth: false,
-  });
-}
-
-export async function signin(email: string, password: string): Promise<AuthResponse> {
-  return request<AuthResponse>('/api/auth/signin', {
-    method: 'POST',
-    body: { email, password },
-    auth: false,
-  });
-}
-
-// Projects API
-export async function createProject(name: string): Promise<CreateProjectResponse> {
-  return request<CreateProjectResponse>('/api/projects', {
-    method: 'POST',
-    body: { name },
-  });
-}
-
-export async function listProjects(): Promise<ProjectListResponse> {
-  return request<ProjectListResponse>('/api/projects', {
-    method: 'GET',
-  });
-}
-
-export async function getProject(id: string): Promise<{ project: CreateProjectResponse['project']; url: string }> {
-  return request('/api/projects/' + id, {
-    method: 'GET',
-  });
-}
-
-export async function deleteProject(id: string): Promise<void> {
-  await request('/api/projects/' + id, {
-    method: 'DELETE',
-  });
-}
-
-// Deployments API
-export async function deploy(projectId: string, files: DeployFile[]): Promise<DeployResponse> {
-  return request<DeployResponse>(`/api/projects/${projectId}/deploy`, {
-    method: 'POST',
-    body: { files },
-  });
-}
-
-export async function getLogs(projectId: string, lines: number = 100): Promise<LogsResponse> {
-  return request<LogsResponse>(`/api/projects/${projectId}/logs?lines=${lines}`, {
-    method: 'GET',
-  });
-}

package/src/lib/config.ts

@@ -1,75 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import os from 'os';
-import type { CliConfig, CliAuth } from '@gazill/shared';
-import { API_BASE_URL } from '@gazill/shared';
-
-const CONFIG_DIR = path.join(os.homedir(), '.gazill');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-const AUTH_FILE = path.join(CONFIG_DIR, 'auth.json');
-
-// Ensure config directory exists
-async function ensureConfigDir(): Promise<void> {
-  try {
-    await fs.mkdir(CONFIG_DIR, { recursive: true });
-  } catch {
-    // Directory might already exist
-  }
-}
-
-// Get CLI configuration
-export async function getConfig(): Promise<CliConfig> {
-  try {
-    const content = await fs.readFile(CONFIG_FILE, 'utf-8');
-    return JSON.parse(content) as CliConfig;
-  } catch {
-    return {
-      apiUrl: API_BASE_URL,
-    };
-  }
-}
-
-// Save CLI configuration
-export async function saveConfig(config: CliConfig): Promise<void> {
-  await ensureConfigDir();
-  await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
-}
-
-// Get authentication info
-export async function getAuth(): Promise<CliAuth | null> {
-  try {
-    const content = await fs.readFile(AUTH_FILE, 'utf-8');
-    return JSON.parse(content) as CliAuth;
-  } catch {
-    return null;
-  }
-}
-
-// Save authentication info
-export async function saveAuth(auth: CliAuth): Promise<void> {
-  await ensureConfigDir();
-  await fs.writeFile(AUTH_FILE, JSON.stringify(auth, null, 2), {
-    mode: 0o600, // Read/write for owner only
-  });
-}
-
-// Clear authentication info
-export async function clearAuth(): Promise<void> {
-  try {
-    await fs.unlink(AUTH_FILE);
-  } catch {
-    // File might not exist
-  }
-}
-
-// Check if user is authenticated
-export async function isAuthenticated(): Promise<boolean> {
-  const auth = await getAuth();
-  return auth !== null && !!auth.token;
-}
-
-// Get API URL
-export async function getApiUrl(): Promise<string> {
-  const config = await getConfig();
-  return config.apiUrl;
-}