ship2-cli 0.1.0 → 0.2.0

package/bin/ship2.js

@@ -17,7 +17,7 @@ const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'))
 
 program
   .name('ship2')
-  .description('Deploy static sites to ship2.app in seconds')
+  .description('Deploy static sites and Next.js apps to ship2.app in seconds')
   .version(pkg.version)
 
 program
@@ -31,6 +31,8 @@ program
   .command('deploy [path]')
   .description('Deploy a file or directory to ship2.app')
   .option('-n, --name <name>', 'Project name (also used as subdomain)')
+  .option('-t, --type <type>', 'Project type: static, nextjs, or auto (default: auto)')
+  .option('-e, --env <KEY=VALUE>', 'Environment variable (can be used multiple times)', (val, prev) => prev ? [...prev, val] : [val])
   .option('--private', 'Create a private deployment')
   .option('--ttl <hours>', 'Link expiration time in hours (private only)')
   .option('--message <text>', 'Deployment message/note')

package/commands/deploy.js

@@ -4,18 +4,22 @@
 
 import { readFileSync, existsSync } from 'fs'
 import { resolve, basename, extname } from 'path'
+import { createInterface } from 'readline'
 import chalk from 'chalk'
 import ora from 'ora'
 import { isLoggedIn, getToken, getApiBase } from '../lib/config.js'
 import {
   detectPathType,
   collectFiles,
+  collectNextjsFiles,
   validateDirectory,
   validateReferences,
   inferProjectName,
   sanitizeProjectName,
   formatSize,
   detectBuildOutput,
+  detectNextjsProject,
+  hasApiRoutes,
   ValidationError
 } from '../lib/files.js'
 import * as output from '../lib/output.js'
@@ -41,6 +45,108 @@ function parseTTL(ttl) {
   }
 }
 
+/**
+ * Prompt user for input
+ */
+function prompt(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close()
+      resolve(answer.trim())
+    })
+  })
+}
+
+/**
+ * Check if subdomain is available
+ */
+async function checkSubdomain(subdomain, token, apiBase) {
+  try {
+    const response = await fetch(`${apiBase}/api/check-subdomain?subdomain=${encodeURIComponent(subdomain)}`, {
+      headers: {
+        'Authorization': `Bearer ${token}`
+      }
+    })
+    return await response.json()
+  } catch (err) {
+    return { error: err.message }
+  }
+}
+
+/**
+ * Interactive subdomain selection
+ */
+async function selectSubdomain(suggestedName, token, apiBase, isJson) {
+  // First check if suggested name is available
+  const check = await checkSubdomain(suggestedName, token, apiBase)
+
+  if (check.available) {
+    if (check.owned) {
+      // User owns this subdomain, will update
+      if (!isJson) {
+        console.log(chalk.dim(`  Domain: ${chalk.cyan(suggestedName + '.ship2.app')} (will update existing)`))
+      }
+      return suggestedName
+    } else {
+      // Available, ask if user wants to use it
+      if (!isJson) {
+        console.log(chalk.dim(`  Suggested domain: ${chalk.cyan(suggestedName + '.ship2.app')}`))
+      }
+      const useDefault = await prompt(`  Use this domain? [Y/n]: `)
+      if (!useDefault || useDefault.toLowerCase() === 'y' || useDefault.toLowerCase() === 'yes') {
+        return suggestedName
+      }
+    }
+  } else {
+    // Not available, inform user
+    if (!isJson) {
+      console.log(chalk.yellow(`  Domain "${suggestedName}.ship2.app" is not available.`))
+    }
+  }
+
+  // Let user enter custom subdomain
+  while (true) {
+    const customName = await prompt(`  Enter subdomain (3-63 chars, lowercase, hyphens ok): `)
+
+    if (!customName) {
+      console.log(chalk.red('  Subdomain is required.'))
+      continue
+    }
+
+    const sanitized = sanitizeProjectName(customName)
+    if (sanitized.length < 3) {
+      console.log(chalk.red('  Subdomain must be at least 3 characters.'))
+      continue
+    }
+
+    // Check availability
+    const spinner = ora('Checking availability...').start()
+    const checkResult = await checkSubdomain(sanitized, token, apiBase)
+    spinner.stop()
+
+    if (checkResult.error) {
+      console.log(chalk.red(`  Error: ${checkResult.error}`))
+      continue
+    }
+
+    if (checkResult.available) {
+      if (checkResult.owned) {
+        console.log(chalk.dim(`  Will update existing project at ${chalk.cyan(sanitized + '.ship2.app')}`))
+      } else {
+        console.log(chalk.green(`  Domain ${chalk.cyan(sanitized + '.ship2.app')} is available!`))
+      }
+      return sanitized
+    } else {
+      console.log(chalk.yellow(`  Domain "${sanitized}.ship2.app" is already taken. Try another name.`))
+    }
+  }
+}
+
 export default async function deploy(inputPath, options) {
   // Default to current directory
   const targetPath = resolve(inputPath || '.')
@@ -57,6 +163,24 @@ export default async function deploy(inputPath, options) {
   // Detect path type
   const pathInfo = detectPathType(targetPath)
 
+  // Detect project type (auto-detect or from --type flag)
+  let projectType = options.type || 'auto'
+  if (projectType === 'auto' && pathInfo.type === 'directory') {
+    if (detectNextjsProject(targetPath)) {
+      projectType = 'nextjs'
+      if (!isJson) {
+        const hasApi = hasApiRoutes(targetPath)
+        if (hasApi) {
+          console.log(chalk.cyan('  Detected: Next.js project with API routes'))
+        } else {
+          console.log(chalk.cyan('  Detected: Next.js project'))
+        }
+      }
+    } else {
+      projectType = 'static'
+    }
+  }
+
   if (pathInfo.type === 'not_found') {
     output.deployError({
       code: 'NOT_FOUND',
@@ -75,21 +199,76 @@ export default async function deploy(inputPath, options) {
     process.exit(1)
   }
 
-  // Infer project name
-  let projectName = options.name || inferProjectName(targetPath)
-  projectName = sanitizeProjectName(projectName)
+  // Infer project name from directory/file
+  let suggestedName = inferProjectName(targetPath)
+  suggestedName = sanitizeProjectName(suggestedName)
 
-  if (!projectName) {
-    projectName = 'my-site'
+  if (!suggestedName || suggestedName.length < 3) {
+    suggestedName = 'my-site'
   }
 
-  if (!isJson) {
+  const apiBase = getApiBase()
+  const token = getToken()
+
+  // Determine subdomain
+  let projectName
+
+  if (options.name) {
+    // User specified name via --name flag
+    const sanitized = sanitizeProjectName(options.name)
+    if (sanitized.length < 3) {
+      output.deployError({
+        code: 'INVALID_NAME',
+        message: 'Project name must be at least 3 characters.',
+        suggestion: 'Use a longer name with lowercase letters, numbers, and hyphens.'
+      }, isJson)
+      process.exit(1)
+    }
+
+    // Check if available
+    const check = await checkSubdomain(sanitized, token, apiBase)
+    if (!check.available && !check.owned) {
+      output.deployError({
+        code: 'NAME_TAKEN',
+        message: `Domain "${sanitized}.ship2.app" is already taken.`,
+        suggestion: 'Try a different name with --name flag.'
+      }, isJson)
+      process.exit(1)
+    }
+
+    projectName = sanitized
+    if (!isJson) {
+      if (check.owned) {
+        console.log()
+        output.info(`Updating: ${chalk.cyan(projectName + '.ship2.app')}`)
+      } else {
+        console.log()
+        output.info(`Deploying to: ${chalk.cyan(projectName + '.ship2.app')}`)
+      }
+    }
+  } else if (!isJson) {
+    // Interactive mode: ask user to confirm/change subdomain
     console.log()
     if (isPrivate) {
-      output.info(`Creating private link: ${chalk.cyan(projectName)}`)
+      output.info(`Creating private link`)
+      projectName = suggestedName
     } else {
-      output.info(`Deploying: ${chalk.cyan(projectName)}`)
+      output.info(`Setting up deployment`)
+      projectName = await selectSubdomain(suggestedName, token, apiBase, isJson)
     }
+    console.log()
+  } else {
+    // JSON mode without --name: use suggested name, check availability
+    const check = await checkSubdomain(suggestedName, token, apiBase)
+    if (!check.available && !check.owned) {
+      output.deployError({
+        code: 'NAME_TAKEN',
+        message: `Domain "${suggestedName}.ship2.app" is already taken.`,
+        suggestion: 'Specify a custom name with --name flag.'
+      }, isJson)
+      process.exit(1)
+    }
+    projectName = suggestedName
   }
 
   let files = []
@@ -123,79 +302,129 @@ export default async function deploy(inputPath, options) {
 
   // Handle directory
   if (pathInfo.type === 'directory') {
-    if (!isJson) {
-      output.info('Mode: Directory')
-    }
+    // Next.js project deployment
+    if (projectType === 'nextjs') {
+      if (!isJson) {
+        output.info('Mode: Next.js Full-Stack')
+      }
 
-    // Validate directory has index.html
-    const dirValidation = validateDirectory(targetPath)
-    if (!dirValidation.valid) {
-      // Check for build output directories
-      const buildDir = detectBuildOutput(targetPath)
-      if (buildDir) {
-        output.deployError({
-          code: 'MISSING_INDEX',
-          message: 'No index.html found in current directory.',
-          suggestion: `Detected build output. Try: ship2 deploy ${buildDir}`
-        }, isJson)
-      } else {
+      // Collect Next.js project files
+      const spinner = isJson ? null : ora('Scanning Next.js project...').start()
+
+      try {
+        const result = await collectNextjsFiles(targetPath)
+
+        if (result.errors.length > 0) {
+          if (spinner) spinner.fail('Validation failed')
+
+          for (const error of result.errors) {
+            if (error.type === ValidationError.FILE_TOO_LARGE) {
+              output.deployError({
+                code: 'FILE_TOO_LARGE',
+                message: `File too large: ${error.file} (${formatSize(error.size)}, limit: ${formatSize(error.maxSize)})`,
+                suggestion: 'Compress or remove the file.'
+              }, isJson)
+            } else if (error.type === ValidationError.TOTAL_TOO_LARGE) {
+              output.deployError({
+                code: 'TOTAL_TOO_LARGE',
+                message: `Total size too large: ${formatSize(error.totalSize)} (limit: ${formatSize(error.maxSize)})`,
+                suggestion: 'Remove unnecessary files or compress assets.'
+              }, isJson)
+            }
+          }
+          process.exit(1)
+        }
+
+        files = result.files
+        totalSize = result.totalSize
+
+        if (spinner) {
+          spinner.succeed(`Scanned: ${files.length} files, ${formatSize(totalSize)}`)
+        }
+      } catch (err) {
+        if (spinner) spinner.fail('Scan failed')
         output.deployError({
-          code: 'MISSING_INDEX',
-          message: 'No index.html found.',
-          suggestion: 'Run your build command first, then deploy the output directory.\nExample: npm run build && ship2 deploy ./dist'
+          code: 'SCAN_FAILED',
+          message: err.message
         }, isJson)
+        process.exit(1)
+      }
+    } else {
+      // Static project deployment (original logic)
+      if (!isJson) {
+        output.info('Mode: Static')
       }
-      process.exit(1)
-    }
-
-    // Validate references
-    const indexContent = readFileSync(resolve(targetPath, 'index.html'), 'utf8')
-    const refValidation = validateReferences(targetPath, indexContent)
-    if (!refValidation.valid) {
-      output.deployError(refValidation.error, isJson)
-      process.exit(1)
-    }
 
-    // Collect files
-    const spinner = isJson ? null : ora('Scanning files...').start()
-
-    try {
-      const result = await collectFiles(targetPath)
-
-      if (result.errors.length > 0) {
-        if (spinner) spinner.fail('Validation failed')
-
-        for (const error of result.errors) {
-          if (error.type === ValidationError.FILE_TOO_LARGE) {
-            output.deployError({
-              code: 'FILE_TOO_LARGE',
-              message: `File too large: ${error.file} (${formatSize(error.size)}, limit: ${formatSize(error.maxSize)})`,
-              suggestion: 'Compress or remove the file.'
-            }, isJson)
-          } else if (error.type === ValidationError.TOTAL_TOO_LARGE) {
-            output.deployError({
-              code: 'TOTAL_TOO_LARGE',
-              message: `Total size too large: ${formatSize(error.totalSize)} (limit: ${formatSize(error.maxSize)})`,
-              suggestion: 'Remove unnecessary files or compress assets.'
-            }, isJson)
-          }
+      // Validate directory has index.html
+      const dirValidation = validateDirectory(targetPath)
+      if (!dirValidation.valid) {
+        // Check for build output directories
+        const buildDir = detectBuildOutput(targetPath)
+        if (buildDir) {
+          output.deployError({
+            code: 'MISSING_INDEX',
+            message: 'No index.html found in current directory.',
+            suggestion: `Detected build output. Try: ship2 deploy ${buildDir}`
+          }, isJson)
+        } else {
+          output.deployError({
+            code: 'MISSING_INDEX',
+            message: 'No index.html found.',
+            suggestion: 'Run your build command first, then deploy the output directory.\nExample: npm run build && ship2 deploy ./dist'
+          }, isJson)
         }
         process.exit(1)
       }
 
-      files = result.files
-      totalSize = result.totalSize
+      // Validate references
+      const indexContent = readFileSync(resolve(targetPath, 'index.html'), 'utf8')
+      const refValidation = validateReferences(targetPath, indexContent)
+      if (!refValidation.valid) {
+        output.deployError(refValidation.error, isJson)
+        process.exit(1)
+      }
+
+      // Collect files
+      const spinner = isJson ? null : ora('Scanning files...').start()
+
+      try {
+        const result = await collectFiles(targetPath)
+
+        if (result.errors.length > 0) {
+          if (spinner) spinner.fail('Validation failed')
+
+          for (const error of result.errors) {
+            if (error.type === ValidationError.FILE_TOO_LARGE) {
+              output.deployError({
+                code: 'FILE_TOO_LARGE',
+                message: `File too large: ${error.file} (${formatSize(error.size)}, limit: ${formatSize(error.maxSize)})`,
+                suggestion: 'Compress or remove the file.'
+              }, isJson)
+            } else if (error.type === ValidationError.TOTAL_TOO_LARGE) {
+              output.deployError({
+                code: 'TOTAL_TOO_LARGE',
+                message: `Total size too large: ${formatSize(error.totalSize)} (limit: ${formatSize(error.maxSize)})`,
+                suggestion: 'Remove unnecessary files or compress assets.'
+              }, isJson)
+            }
+          }
+          process.exit(1)
+        }
 
-      if (spinner) {
-        spinner.succeed(`Scanned: ${files.length} files, ${formatSize(totalSize)}`)
+        files = result.files
+        totalSize = result.totalSize
+
+        if (spinner) {
+          spinner.succeed(`Scanned: ${files.length} files, ${formatSize(totalSize)}`)
+        }
+      } catch (err) {
+        if (spinner) spinner.fail('Scan failed')
+        output.deployError({
+          code: 'SCAN_FAILED',
+          message: err.message
+        }, isJson)
+        process.exit(1)
       }
-    } catch (err) {
-      if (spinner) spinner.fail('Scan failed')
-      output.deployError({
-        code: 'SCAN_FAILED',
-        message: err.message
-      }, isJson)
-      process.exit(1)
     }
   }
 
@@ -203,9 +432,6 @@ export default async function deploy(inputPath, options) {
   const deploySpinner = isJson ? null : ora(isPrivate ? 'Creating private link...' : 'Deploying...').start()
 
   try {
-    const apiBase = getApiBase()
-    const token = getToken()
-
     // Private deployment
     if (isPrivate) {
       const ttlHours = parseTTL(options.ttl)
@@ -246,23 +472,66 @@ export default async function deploy(inputPath, options) {
     }
 
     // Public deployment
-    const response = await fetch(`${apiBase}/api/publish-multi`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${token}`
-      },
-      body: JSON.stringify({
-        files: files.map(f => ({ path: f.path, content: f.content })),
-        projectName,
-        subdomain: projectName,
-        meta: {
-          title: projectName,
-          platform: 'CLI',
-          message: options.message || ''
+    let response
+    let apiEndpoint
+
+    if (projectType === 'nextjs') {
+      // Next.js full-stack deployment
+      apiEndpoint = `${apiBase}/api/deploy-nextjs`
+
+      // Parse environment variables from --env flags
+      const envVars = {}
+      if (options.env) {
+        const envList = Array.isArray(options.env) ? options.env : [options.env]
+        for (const envStr of envList) {
+          const eqIndex = envStr.indexOf('=')
+          if (eqIndex > 0) {
+            const key = envStr.slice(0, eqIndex)
+            const value = envStr.slice(eqIndex + 1)
+            envVars[key] = value
+          }
         }
+      }
+
+      response = await fetch(apiEndpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          files: files.map(f => ({ path: f.path, content: f.content, encoding: f.encoding })),
+          projectName,
+          subdomain: projectName,
+          env: envVars,
+          meta: {
+            title: projectName,
+            platform: 'CLI',
+            message: options.message || ''
+          }
+        })
       })
-    })
+    } else {
+      // Static deployment (original)
+      apiEndpoint = `${apiBase}/api/publish-multi`
+      response = await fetch(apiEndpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          files: files.map(f => ({ path: f.path, content: f.content })),
+          projectName,
+          subdomain: projectName,
+          meta: {
+            title: projectName,
+            platform: 'CLI',
+            message: options.message || ''
+          }
+        })
+      })
+    }
 
     const data = await response.json()
 
@@ -275,12 +544,19 @@ export default async function deploy(inputPath, options) {
       process.exit(1)
     }
 
-    if (deploySpinner) deploySpinner.succeed('Deployed')
+    if (deploySpinner) {
+      if (projectType === 'nextjs') {
+        deploySpinner.succeed('Deployed (Vercel is building...)')
+      } else {
+        deploySpinner.succeed('Deployed')
+      }
+    }
 
     output.deployResult({
       ...data,
       projectName,
-      totalSize
+      totalSize,
+      projectType
     }, isJson)
 
   } catch (err) {

package/lib/files.js

@@ -10,11 +10,26 @@ import mime from 'mime-types'
 // File size limits
 const MAX_FILE_SIZE = 5 * 1024 * 1024  // 5MB per file
 const MAX_TOTAL_SIZE = 10 * 1024 * 1024  // 10MB total (Free tier)
+const MAX_TOTAL_SIZE_NEXTJS = 50 * 1024 * 1024  // 50MB total for Next.js projects
 
 // Common build output directories
 const BUILD_DIRS = ['dist', 'build', 'out', 'public', '.next/static', '.output/public']
 
-// Ignore patterns
+// Binary file extensions (use base64 encoding)
+const BINARY_EXTENSIONS = new Set([
+  // Images
+  '.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.bmp', '.svg', '.avif',
+  // Fonts
+  '.woff', '.woff2', '.ttf', '.otf', '.eot',
+  // Audio/Video
+  '.mp3', '.mp4', '.webm', '.ogg', '.wav', '.m4a',
+  // Archives
+  '.zip', '.gz', '.tar', '.rar',
+  // Other binary
+  '.pdf', '.wasm', '.bin'
+])
+
+// Ignore patterns for static projects
 const IGNORE_PATTERNS = [
   'node_modules/**',
   '.git/**',
@@ -26,6 +41,27 @@ const IGNORE_PATTERNS = [
   '.vscode/**'
 ]
 
+// Ignore patterns for Next.js projects
+const NEXTJS_IGNORE_PATTERNS = [
+  'node_modules/**',
+  '.next/**',
+  '.git/**',
+  '.DS_Store',
+  'Thumbs.db',
+  '*.log',
+  '.env',
+  '.env.local',
+  '.env.*.local',
+  '.vercel/**',
+  'coverage/**',
+  '.nyc_output/**',
+  '.idea/**',
+  '.vscode/**',
+  'out/**',
+  'dist/**',
+  'build/**'
+]
+
 /**
  * Validation error types
  */
@@ -110,12 +146,24 @@ export async function collectFiles(dirPath) {
 
     totalSize += size
 
-    // Read file content
-    const content = readFileSync(fullPath, 'utf8')
+    // Read file content - use base64 for binary files
+    const ext = extname(file).toLowerCase()
+    const isBinary = BINARY_EXTENSIONS.has(ext)
+
+    let content
+    let encoding = 'utf8'
+
+    if (isBinary) {
+      content = readFileSync(fullPath).toString('base64')
+      encoding = 'base64'
+    } else {
+      content = readFileSync(fullPath, 'utf8')
+    }
 
     result.push({
       path: file,
       content,
+      encoding,
       size
     })
   }
@@ -253,3 +301,101 @@ export function formatSize(bytes) {
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
   return `${(bytes / (1024 * 1024)).toFixed(2)} MB`
 }
+
+/**
+ * Detect if directory is a Next.js project
+ */
+export function detectNextjsProject(dirPath) {
+  const pkgPath = join(dirPath, 'package.json')
+  if (!existsSync(pkgPath)) return false
+
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+    return !!(pkg.dependencies?.next || pkg.devDependencies?.next)
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Check if Next.js project has API routes
+ */
+export function hasApiRoutes(dirPath) {
+  // App Router API routes
+  const appApiDir = join(dirPath, 'app', 'api')
+  // Pages Router API routes
+  const pagesApiDir = join(dirPath, 'pages', 'api')
+  // Also check src directory
+  const srcAppApiDir = join(dirPath, 'src', 'app', 'api')
+  const srcPagesApiDir = join(dirPath, 'src', 'pages', 'api')
+
+  return existsSync(appApiDir) || existsSync(pagesApiDir) ||
+         existsSync(srcAppApiDir) || existsSync(srcPagesApiDir)
+}
+
+/**
+ * Collect files from a Next.js project
+ */
+export async function collectNextjsFiles(dirPath) {
+  const files = await glob('**/*', {
+    cwd: dirPath,
+    nodir: true,
+    ignore: NEXTJS_IGNORE_PATTERNS,
+    dot: false
+  })
+
+  const result = []
+  let totalSize = 0
+  const errors = []
+
+  for (const file of files) {
+    const fullPath = join(dirPath, file)
+    const stat = statSync(fullPath)
+    const size = stat.size
+
+    // Check single file size
+    if (size > MAX_FILE_SIZE) {
+      errors.push({
+        type: ValidationError.FILE_TOO_LARGE,
+        file,
+        size,
+        maxSize: MAX_FILE_SIZE
+      })
+      continue
+    }
+
+    totalSize += size
+
+    // Read file content - use base64 for binary files
+    const ext = extname(file).toLowerCase()
+    const isBinary = BINARY_EXTENSIONS.has(ext)
+
+    let content
+    let encoding = 'utf8'
+
+    if (isBinary) {
+      content = readFileSync(fullPath).toString('base64')
+      encoding = 'base64'
+    } else {
+      content = readFileSync(fullPath, 'utf8')
+    }
+
+    result.push({
+      path: file,
+      content,
+      encoding,
+      size
+    })
+  }
+
+  // Check total size (use larger limit for Next.js)
+  if (totalSize > MAX_TOTAL_SIZE_NEXTJS) {
+    errors.push({
+      type: ValidationError.TOTAL_TOO_LARGE,
+      totalSize,
+      maxSize: MAX_TOTAL_SIZE_NEXTJS
+    })
+  }
+
+  return { files: result, totalSize, errors }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ship2-cli",
-  "version": "0.1.0",
-  "description": "Deploy static sites to ship2.app in seconds",
+  "version": "0.2.0",
+  "description": "Deploy static sites and Next.js apps to ship2.app in seconds",
   "main": "lib/index.js",
   "bin": {
     "ship2": "./bin/ship2.js"