gazill 1.0.0

package/src/commands/status.ts

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,48 @@
+#!/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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,75 @@
+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;
+}

package/src/lib/watcher.ts

@@ -0,0 +1,181 @@
+import chokidar from 'chokidar';
+import { promises as fs } from 'fs';
+import path from 'path';
+import debounce from 'lodash/debounce.js';
+import chalk from 'chalk';
+import ora from 'ora';
+import type { DeployFile } from '@gazill/shared';
+import { DEPLOY_DEBOUNCE_MS, MAX_FILE_SIZE_BYTES } from '@gazill/shared';
+import { deploy } from './api.js';
+
+const IGNORED_PATTERNS = [
+  /(^|[/\\])\../, // dotfiles
+  'node_modules/**',
+  '.git/**',
+  '*.log',
+  '.gazill/**',
+  'dist/**',
+  'build/**',
+  '__pycache__/**',
+  '*.pyc',
+  '.env',
+  '.env.*',
+  'Dockerfile',
+];
+
+interface WatcherOptions {
+  projectId: string;
+  projectDir: string;
+  onDeploy?: (files: DeployFile[]) => void;
+  onError?: (error: Error) => void;
+}
+
+export async function startWatcher(options: WatcherOptions): Promise<chokidar.FSWatcher> {
+  const { projectId, projectDir, onDeploy, onError } = options;
+
+  const changedFiles = new Set<string>();
+  let isDeploying = false;
+
+  // Collect all files for initial deploy
+  async function collectAllFiles(): Promise<DeployFile[]> {
+    const files: DeployFile[] = [];
+
+    async function walkDir(dir: string): Promise<void> {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(projectDir, fullPath);
+
+        // Skip ignored patterns
+        if (IGNORED_PATTERNS.some((pattern) => {
+          if (typeof pattern === 'string') {
+            return relativePath.includes(pattern.replace('/**', ''));
+          }
+          return pattern.test(relativePath);
+        })) {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          await walkDir(fullPath);
+        } else if (entry.isFile()) {
+          try {
+            const stats = await fs.stat(fullPath);
+            if (stats.size <= MAX_FILE_SIZE_BYTES) {
+              const content = await fs.readFile(fullPath, 'utf-8');
+              files.push({ path: relativePath, content });
+            }
+          } catch {
+            // Skip files that can't be read
+          }
+        }
+      }
+    }
+
+    await walkDir(projectDir);
+    return files;
+  }
+
+  // Deploy changed files
+  const doDeploy = debounce(async () => {
+    if (isDeploying || changedFiles.size === 0) return;
+
+    isDeploying = true;
+    const filesToDeploy = Array.from(changedFiles);
+    changedFiles.clear();
+
+    const spinner = ora('Deploying changes...').start();
+
+    try {
+      const files: DeployFile[] = [];
+
+      for (const filePath of filesToDeploy) {
+        const fullPath = path.join(projectDir, filePath);
+        try {
+          const stats = await fs.stat(fullPath);
+          if (stats.size <= MAX_FILE_SIZE_BYTES) {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            files.push({ path: filePath, content });
+          }
+        } catch {
+          // File might have been deleted
+        }
+      }
+
+      if (files.length > 0) {
+        const result = await deploy(projectId, files);
+        spinner.succeed(
+          chalk.green(`Deployed ${files.length} file(s) - ${result.url}`)
+        );
+        onDeploy?.(files);
+      } else {
+        spinner.info('No files to deploy');
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Deploy failed';
+      spinner.fail(chalk.red(message));
+      onError?.(error instanceof Error ? error : new Error(message));
+    } finally {
+      isDeploying = false;
+    }
+  }, DEPLOY_DEBOUNCE_MS);
+
+  // Create watcher
+  const watcher = chokidar.watch(projectDir, {
+    ignored: IGNORED_PATTERNS,
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 100,
+      pollInterval: 50,
+    },
+  });
+
+  // Handle file changes
+  watcher.on('add', (filePath) => {
+    const relativePath = path.relative(projectDir, filePath);
+    console.log(chalk.gray(`+ ${relativePath}`));
+    changedFiles.add(relativePath);
+    doDeploy();
+  });
+
+  watcher.on('change', (filePath) => {
+    const relativePath = path.relative(projectDir, filePath);
+    console.log(chalk.gray(`~ ${relativePath}`));
+    changedFiles.add(relativePath);
+    doDeploy();
+  });
+
+  watcher.on('unlink', (filePath) => {
+    const relativePath = path.relative(projectDir, filePath);
+    console.log(chalk.gray(`- ${relativePath}`));
+    // Note: File deletion isn't fully handled - would need separate API endpoint
+  });
+
+  watcher.on('error', (error) => {
+    console.error(chalk.red('Watcher error:'), error);
+    onError?.(error);
+  });
+
+  // Initial deploy of all files
+  console.log(chalk.blue('Scanning files...'));
+  const allFiles = await collectAllFiles();
+
+  if (allFiles.length > 0) {
+    const spinner = ora(`Deploying ${allFiles.length} files...`).start();
+    try {
+      const result = await deploy(projectId, allFiles);
+      spinner.succeed(
+        chalk.green(`Initial deploy complete - ${result.url}`)
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Deploy failed';
+      spinner.fail(chalk.red(message));
+    }
+  }
+
+  console.log(chalk.blue('\nWatching for changes... (Ctrl+C to stop)\n'));
+
+  return watcher;
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"]
+}