@jetstart/cli 1.1.1

package/src/cli.ts

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+
+/**
+ * CLI Entry Point
+ * Defines all commands and handles command execution
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { createCommand } from './commands/create';
+import { devCommand } from './commands/dev';
+import { buildCommand } from './commands/build';
+import { logsCommand } from './commands/logs';
+import { JETSTART_VERSION } from '@jetstart/shared';
+
+const program = new Command();
+
+program
+  .name('jetstart')
+  .description('Fast, wireless Android development with Kotlin and Jetpack Compose')
+  .version(JETSTART_VERSION);
+
+// Create command
+program
+  .command('create <name>')
+  .description('Create a new JetStart project')
+  .option('-p, --package <name>', 'Package name (e.g., com.example.app)')
+  .option('-t, --template <name>', 'Template to use', 'default')
+  .option('--skip-install', 'Skip npm install')
+  .action(createCommand);
+
+// Dev command
+program
+  .command('dev')
+  .description('Start development server')
+  .option('-p, --port <port>', 'Port for dev server', '8765')
+  .option('-H, --host <host>', 'Host address (defaults to auto-detected network IP)')
+  .option('--no-qr', 'Do not show QR code')
+  .option('--no-open', 'Do not open browser')
+  .action(devCommand);
+
+// Build command
+program
+  .command('build')
+  .description('Build production APK')
+  .option('-o, --output <path>', 'Output directory', './build')
+  .option('-r, --release', 'Build release version', false)
+  .option('--sign', 'Sign the APK')
+  .action(buildCommand);
+
+// Logs command
+program
+  .command('logs')
+  .description('Stream application logs')
+  .option('-f, --follow', 'Follow log output', true)
+  .option('-l, --level <level>', 'Filter by log level')
+  .option('-s, --source <source>', 'Filter by log source')
+  .option('-n, --lines <number>', 'Number of lines to show', '100')
+  .action(logsCommand);
+
+// Error handling
+program.on('command:*', (operands) => {
+  console.error(chalk.red(`Error: Unknown command '${operands[0]}'`));
+  console.log(chalk.yellow('\nRun "jetstart --help" for available commands'));
+  process.exit(1);
+});
+
+// Handle errors gracefully
+process.on('unhandledRejection', (err: Error) => {
+  console.error(chalk.red('Unhandled error:'), err.message);
+  process.exit(1);
+});
+
+// Parse arguments
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/src/commands/build.ts

@@ -0,0 +1,60 @@
+/**
+ * Build Command
+ * Builds production APK
+ */
+
+import path from 'path';
+import chalk from 'chalk';
+import { log, success, error, info } from '../utils/logger';
+import { startSpinner, stopSpinner } from '../utils/spinner';
+import { BuildType } from '@jetstart/shared';
+
+interface BuildOptions {
+  output?: string;
+  release?: boolean;
+  sign?: boolean;
+}
+
+export async function buildCommand(options: BuildOptions) {
+  try {
+    const buildType = options.release ? BuildType.RELEASE : BuildType.DEBUG;
+    const outputDir = options.output || './build';
+
+    log(`Building ${buildType} APK...`);
+    console.log();
+
+    // Validate project
+    const spinner = startSpinner('Validating project...');
+    await new Promise(resolve => setTimeout(resolve, 500));
+    stopSpinner(spinner, true, 'Project validated');
+
+    // Compile Kotlin
+    const compileSpinner = startSpinner('Compiling Kotlin sources...');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    stopSpinner(compileSpinner, true, 'Kotlin compiled');
+
+    // Package APK
+    const packageSpinner = startSpinner('Packaging APK...');
+    await new Promise(resolve => setTimeout(resolve, 1500));
+    stopSpinner(packageSpinner, true, 'APK packaged');
+
+    // Sign APK (if release)
+    if (options.release && options.sign) {
+      const signSpinner = startSpinner('Signing APK...');
+      await new Promise(resolve => setTimeout(resolve, 800));
+      stopSpinner(signSpinner, true, 'APK signed');
+    }
+
+    console.log();
+    success('Build completed successfully!');
+    console.log();
+    info(`Output: ${chalk.cyan(path.resolve(outputDir))}`);
+    info(`Size: ${chalk.cyan('5.2 MB')}`);
+    info(`Type: ${chalk.cyan(buildType)}`);
+    console.log();
+
+  } catch (err: any) {
+    error(`Build failed: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/create.ts

@@ -0,0 +1,109 @@
+/**
+ * Create Command
+ * Scaffolds a new JetStart project
+ */
+
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import { log, success, error } from '../utils/logger';
+import { startSpinner, stopSpinner } from '../utils/spinner';
+import { prompt } from '../utils/prompt';
+import { generateProjectTemplate } from '../utils/template';
+import { isValidProjectName, isValidPackageName } from '@jetstart/shared';
+
+interface CreateOptions {
+  package?: string;
+  template?: string;
+  skipInstall?: boolean;
+}
+
+export async function createCommand(name: string, options: CreateOptions) {
+  try {
+    // Validate project name
+    if (!isValidProjectName(name)) {
+      error('Invalid project name. Use letters, numbers, hyphens, and underscores only.');
+      error('Project name must start with a letter and be 1-64 characters long.');
+      process.exit(1);
+    }
+
+    const projectPath = path.resolve(process.cwd(), name);
+
+    // Check if directory already exists
+    if (await fs.pathExists(projectPath)) {
+      error(`Directory '${name}' already exists!`);
+      process.exit(1);
+    }
+
+    log(`Creating JetStart project: ${chalk.cyan(name)}`);
+    console.log();
+
+    // Get package name
+    let packageName = options.package;
+    if (!packageName) {
+      const defaultPackage = `com.jetstart.${name.toLowerCase().replace(/[^a-z0-9]/g, '')}`;
+      const answer = await prompt({
+        type: 'input',
+        name: 'packageName',
+        message: 'Package name:',
+        default: defaultPackage,
+        validate: (input: string) => {
+          if (!isValidPackageName(input)) {
+            return 'Invalid package name. Use format: com.company.app';
+          }
+          return true;
+        },
+      });
+      packageName = answer.packageName;
+    }
+
+    // Validate package name
+    if (!isValidPackageName(packageName!)) {
+      error('Invalid package name. Use format: com.company.app');
+      process.exit(1);
+    }
+
+    // Create project structure
+    const spinner = startSpinner('Creating project structure...');
+
+    try {
+      await fs.ensureDir(projectPath);
+
+      // Generate project files
+      await generateProjectTemplate(projectPath, {
+        projectName: name,
+        packageName: packageName!,
+        template: options.template || 'default',
+      });
+
+      stopSpinner(spinner, true, 'Project structure created');
+
+      // Install dependencies
+      if (!options.skipInstall) {
+        const installSpinner = startSpinner('Installing dependencies...');
+        
+        // In a real implementation, we'd run npm/gradle here
+        // For now, we'll simulate it
+        await new Promise(resolve => setTimeout(resolve, 1000));
+
+        stopSpinner(installSpinner, true, 'Dependencies installed');
+      }
+
+      console.log();
+      success(`Successfully created project: ${chalk.cyan(name)}`);
+      console.log();
+      console.log(chalk.bold('Next steps:'));
+      console.log(`  ${chalk.cyan('cd')} ${name}`);
+      console.log(`  ${chalk.cyan('jetstart dev')}`);
+      console.log();
+
+    } catch (err: any) {
+      stopSpinner(spinner, false, 'Failed to create project');
+      throw err;
+    }
+
+  } catch (err: any) {
+    error(`Failed to create project: ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/commands/dev.ts

@@ -0,0 +1,138 @@
+/**
+ * Dev Command
+ * Starts the development server
+ */
+
+import * as path from 'path';
+import * as os from 'os';
+import chalk from 'chalk';
+import qrcode from 'qrcode-terminal';
+import { log, success, error, info } from '../utils/logger';
+import { JetStartServer } from '@jetstart/core';
+import { DEFAULT_CORE_PORT, DEFAULT_WS_PORT } from '@jetstart/shared';
+
+interface DevOptions {
+  port?: string;
+  host?: string;
+  qr?: boolean;
+  open?: boolean;
+}
+
+export async function devCommand(options: DevOptions) {
+  try {
+    const port = parseInt(options.port || String(DEFAULT_CORE_PORT));
+    const wsPort = DEFAULT_WS_PORT;
+    const host = options.host || getLocalIP();
+    const showQR = options.qr !== false;
+
+    log('Starting JetStart development server...');
+    console.log();
+
+    // Get project path and name
+    const projectPath = process.cwd();
+    const projectName = path.basename(projectPath);
+
+    // Create and start Core server
+    // Bind to 0.0.0.0 to accept connections on all interfaces,
+    // but pass the detected IP for display and client connections
+    const server = new JetStartServer({
+      httpPort: port,
+      wsPort,
+      host: '0.0.0.0', // Bind to all interfaces for maximum compatibility
+      displayHost: host, // Use detected IP for display and client connections
+      projectPath,
+      projectName,
+    });
+
+    const session = await server.start();
+
+    // Get URLs
+    const serverUrl = `http://${host}:${port}`;
+    const wsUrl = `ws://${host}:${wsPort}`;
+    const localUrl = `http://localhost:${port}`;
+
+    console.log();
+    success('JetStart dev server is running!');
+    console.log();
+    info(`Local:    ${chalk.cyan(localUrl)}`);
+    info(`Network:  ${chalk.cyan(serverUrl)}`);
+    info(`Project:  ${chalk.cyan(projectName)}`);
+    console.log();
+
+    // Generate QR code for mobile connection
+    if (showQR) {
+      const qrData = {
+        serverUrl,
+        wsUrl,
+        sessionId: session.id,
+        token: session.token,
+        projectName,
+        version: '0.1.0',
+      };
+
+      console.log(chalk.bold('Scan QR or connect manually:'));
+      qrcode.generate(JSON.stringify(qrData), { small: true });
+      console.log();
+      info(`IP: ${chalk.cyan(host)}`);
+      info(`Session: ${chalk.dim(session.id)}`);
+      info(`Token: ${chalk.dim(session.token)}`);
+    }
+
+    info('Watching for file changes...');
+    info('Press Ctrl+C to stop');
+    console.log();
+
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+      console.log();
+      log('Shutting down dev server...');
+      await server.stop();
+      process.exit(0);
+    });
+
+    process.on('SIGTERM', async () => {
+      console.log();
+      log('Shutting down dev server...');
+      await server.stop();
+      process.exit(0);
+    });
+
+    // Keep process alive
+    await new Promise(() => {}); // Keep alive forever
+
+  } catch (err: any) {
+    error(`Failed to start dev server: ${err.message}`);
+    console.error(err.stack);
+    process.exit(1);
+  }
+}
+
+function getLocalIP(): string {
+  const interfaces = os.networkInterfaces();
+  const addresses: string[] = [];
+
+  for (const name of Object.keys(interfaces)) {
+    const iface = interfaces[name];
+    if (!iface) continue;
+
+    for (const alias of iface) {
+      // Handle both 'IPv4' string (Node.js 18+) and numeric 4 (older versions)
+      const isIPv4 = alias.family === 'IPv4' || (alias.family as any) === 4;
+
+      if (isIPv4 && !alias.internal) {
+        // Prefer addresses starting with 192.168 (typical home/hotspot network)
+        if (alias.address.startsWith('192.168')) {
+          return alias.address;
+        }
+        addresses.push(alias.address);
+      }
+    }
+  }
+
+  // Return first non-internal IPv4 address found
+  if (addresses.length > 0) {
+    return addresses[0];
+  }
+
+  return 'localhost';
+}

package/src/commands/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Export all commands
+ */
+
+export { createCommand } from './create';
+export { devCommand } from './dev';
+export { buildCommand } from './build';
+export { logsCommand } from './logs';

package/src/commands/logs.ts

@@ -0,0 +1,117 @@
+/**
+ * Logs Command
+ * Streams application logs
+ */
+
+import chalk from 'chalk';
+import WebSocket from 'ws';
+import { log, error, info } from '../utils/logger';
+import { LogLevel, LogSource, LogEntry, DEFAULT_LOGS_PORT } from '@jetstart/shared';
+
+interface LogsOptions {
+  follow?: boolean;
+  level?: string;
+  source?: string;
+  lines?: string;
+}
+
+export async function logsCommand(options: LogsOptions) {
+  try {
+    // const follow = options.follow !== false;
+    const maxLines = parseInt(options.lines || '100');
+
+    log('Connecting to JetStart logs service...');
+    console.log();
+
+    // Connect to logs service via WebSocket
+    const ws = new WebSocket(`ws://localhost:${DEFAULT_LOGS_PORT}`);
+
+    ws.on('open', () => {
+      info('Connected to logs service');
+      console.log();
+
+      // Send filter options
+      ws.send(JSON.stringify({
+        type: 'subscribe',
+        filter: {
+          levels: options.level ? [options.level] : undefined,
+          sources: options.source ? [options.source] : undefined,
+        },
+        maxLines,
+      }));
+    });
+
+    ws.on('message', (data: string) => {
+      try {
+        const logEntry: LogEntry = JSON.parse(data);
+        formatLogEntry(logEntry);
+      } catch (err) {
+        console.log(data);
+      }
+    });
+
+    ws.on('error', (err) => {
+      error(`WebSocket error: ${err.message}`);
+      process.exit(1);
+    });
+
+    ws.on('close', () => {
+      console.log();
+      info('Disconnected from logs service');
+      process.exit(0);
+    });
+
+    // Handle Ctrl+C
+    process.on('SIGINT', () => {
+      console.log();
+      log('Closing connection...');
+      ws.close();
+    });
+
+  } catch (err: any) {
+    error(`Failed to connect to logs: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function formatLogEntry(entry: LogEntry) {
+  const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+  const level = formatLogLevel(entry.level);
+  const source = formatLogSource(entry.source);
+  const tag = chalk.gray(`[${entry.tag}]`);
+
+  console.log(`${chalk.gray(timestamp)} ${level} ${source} ${tag} ${entry.message}`);
+}
+
+function formatLogLevel(level: LogLevel): string {
+  switch (level) {
+    case LogLevel.VERBOSE:
+      return chalk.gray('VERBOSE');
+    case LogLevel.DEBUG:
+      return chalk.blue('DEBUG');
+    case LogLevel.INFO:
+      return chalk.green('INFO');
+    case LogLevel.WARN:
+      return chalk.yellow('WARN');
+    case LogLevel.ERROR:
+      return chalk.red('ERROR');
+    case LogLevel.FATAL:
+      return chalk.bgRed.white('FATAL');
+    default:
+      return level;
+  }
+}
+
+function formatLogSource(source: LogSource): string {
+  const sourceColors: Record<LogSource, (text: string) => string> = {
+    [LogSource.CLI]: chalk.cyan,
+    [LogSource.CORE]: chalk.magenta,
+    [LogSource.CLIENT]: chalk.green,
+    [LogSource.BUILD]: chalk.yellow,
+    [LogSource.NETWORK]: chalk.blue,
+    [LogSource.SYSTEM]: chalk.gray,
+  };
+
+  const colorFn = sourceColors[source] || chalk.white;
+  return colorFn(`[${source}]`);
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Main entry point for programmatic API
+ */
+
+export * from './commands';
+export * from './types';
+export * from './utils';
+
+// Re-export shared types that CLI users might need
+export type {
+  Session,
+  SessionStatus,
+  BuildConfig,
+  BuildResult,
+  DeviceInfo,
+  LogLevel,
+} from '@jetstart/shared';

package/src/types/index.ts

@@ -0,0 +1,22 @@
+/**
+ * CLI-specific types
+ */
+
+export interface ProjectConfig {
+  projectName: string;
+  packageName: string;
+  template: string;
+  minSdkVersion?: number;
+  targetSdkVersion?: number;
+}
+
+export interface TemplateOptions {
+  projectName: string;
+  packageName: string;
+  template: string;
+}
+
+export interface CommandContext {
+  cwd: string;
+  config?: ProjectConfig;
+}

package/src/utils/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Export all utilities
+ */
+
+export * from './logger';
+export * from './spinner';
+export * from './prompt';
+export * from './template';

package/src/utils/logger.ts

@@ -0,0 +1,42 @@
+/**
+ * Logger Utility
+ * Formatted console output with colors
+ */
+
+import chalk from 'chalk';
+
+export function log(message: string) {
+  console.log(message);
+}
+
+export function info(message: string) {
+  console.log(chalk.blue('ℹ'), message);
+}
+
+export function success(message: string) {
+  console.log(chalk.green('✔'), message);
+}
+
+export function warning(message: string) {
+  console.log(chalk.yellow('⚠'), message);
+}
+
+export function error(message: string) {
+  console.error(chalk.red('✖'), message);
+}
+
+export function debug(message: string) {
+  if (process.env.DEBUG) {
+    console.log(chalk.gray('[DEBUG]'), message);
+  }
+}
+
+export function banner() {
+  console.log();
+  console.log(chalk.cyan.bold('  ╔═╗┌─┐┌┬┐╔═╗┌┬┐┌─┐┬─┐┌┬┐'));
+  console.log(chalk.cyan.bold('    ║├┤  │ ╚═╗ │ ├─┤├┬┘ │ '));
+  console.log(chalk.cyan.bold('  ╚═╝└─┘ ┴ ╚═╝ ┴ ┴ ┴┴└─ ┴ '));
+  console.log();
+  console.log(chalk.gray('  Fast, wireless Android development'));
+  console.log();
+}

package/src/utils/prompt.ts

@@ -0,0 +1,56 @@
+/**
+ * Prompt Utility
+ * User input prompts
+ */
+
+import inquirer from 'inquirer';
+
+export async function prompt(question: inquirer.QuestionCollection) {
+  return inquirer.prompt([question]);
+}
+
+export async function confirm(message: string, defaultValue = true): Promise<boolean> {
+  const answer = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message,
+      default: defaultValue,
+    },
+  ]);
+  return answer.confirmed;
+}
+
+export async function select(
+  message: string,
+  choices: string[],
+  defaultValue?: string
+): Promise<string> {
+  const answer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selected',
+      message,
+      choices,
+      default: defaultValue,
+    },
+  ]);
+  return answer.selected;
+}
+
+export async function input(
+  message: string,
+  defaultValue?: string,
+  validate?: (input: string) => boolean | string
+): Promise<string> {
+  const answer = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'value',
+      message,
+      default: defaultValue,
+      validate,
+    },
+  ]);
+  return answer.value;
+}

package/src/utils/spinner.ts

@@ -0,0 +1,25 @@
+/**
+ * Spinner Utility
+ * Loading spinners for long-running operations
+ */
+
+import ora, { Ora } from 'ora';
+
+export function startSpinner(text: string): Ora {
+  return ora({
+    text,
+    color: 'cyan',
+  }).start();
+}
+
+export function stopSpinner(spinner: Ora, success: boolean, text?: string) {
+  if (success) {
+    spinner.succeed(text || spinner.text);
+  } else {
+    spinner.fail(text || spinner.text);
+  }
+}
+
+export function updateSpinner(spinner: Ora, text: string) {
+  spinner.text = text;
+}