slipway-cli 0.0.0

package/src/commands/slide.js

@@ -0,0 +1,310 @@
+import { execFileSync } from 'node:child_process'
+import { c } from '../lib/colors.js'
+import { api } from '../lib/api.js'
+import { isLoggedIn, getCredentials } from '../lib/config.js'
+import { error, requireProject, createSpinner } from '../lib/utils.js'
+
+export default async function slide(options) {
+  if (!isLoggedIn()) {
+    error('Not logged in. Run `slipway login` first.')
+  }
+
+  const project = requireProject()
+  const environment = options.env || 'production'
+
+  console.log()
+  console.log(`  ${c.bold(c.highlight('Sliding'))} ${project.project} ${c.dim('into')} ${environment}`)
+  console.log()
+
+  // 1. Package source code
+  const spin = createSpinner('Packaging source...').start()
+
+  let tarballBuffer
+  try {
+    tarballBuffer = createTarball()
+    const sizeMB = (tarballBuffer.length / 1024 / 1024).toFixed(1)
+    spin.succeed(`Source packaged (${sizeMB} MB)`)
+  } catch (err) {
+    spin.fail('Failed to package source')
+    error(err.message)
+  }
+
+  // 2. Upload source to server
+  const pushSpin = createSpinner('Pushing source...').start()
+
+  try {
+    await api.projects.push(project.project, tarballBuffer)
+    pushSpin.succeed('Source pushed')
+  } catch (err) {
+    pushSpin.fail('Failed to push source')
+    error(err.message)
+  }
+
+  // 3. Trigger deployment
+  const deploySpin = createSpinner('Starting deployment...').start()
+
+  try {
+    const { deployment } = await api.deployments.trigger(
+      project.project,
+      environment,
+      {
+        message: options.message,
+        ...getGitInfo()
+      }
+    )
+
+    deploySpin.succeed('Deployment started')
+    console.log()
+    console.log(`  ${c.dim('Deployment ID:')} ${deployment.id.substring(0, 8)}`)
+    console.log()
+
+    // 4. Watch deployment status via SSE (with polling fallback)
+    const result = await watchDeployment(deployment.id)
+
+    if (result.status === 'running') {
+      console.log(`  ${c.success('✓')} Deployment successful`)
+      console.log()
+
+      // Get environment info to show URL
+      try {
+        const { environment: env } = await api.environments.get(project.project, environment)
+        if (env.url) {
+          console.log(`  ${c.dim('URL:')} ${c.highlight(env.url)}`)
+          console.log()
+        }
+      } catch {
+        // Ignore errors fetching URL
+      }
+    } else if (result.status === 'failed') {
+      console.log(`  ${c.error('✗')} Deployment failed`)
+      console.log()
+      console.log(`  ${c.dim('Run')} ${c.highlight(`slipway logs -d ${deployment.id.substring(0, 8)}`)} ${c.dim('to view logs.')}`)
+      console.log()
+      process.exit(1)
+    } else {
+      console.log(`  ${c.warn('!')} Deployment ended with status: ${result.status}`)
+      console.log()
+    }
+  } catch (err) {
+    deploySpin.fail('Deployment failed')
+    error(err.message)
+  }
+}
+
+/**
+ * Create a tarball of the current directory.
+ * Uses `git archive` if in a git repo (respects .gitignore automatically),
+ * otherwise falls back to `tar` with sensible exclusions.
+ */
+function createTarball() {
+  const cwd = process.cwd()
+
+  // Check if we're in a git repo
+  if (isGitRepo(cwd)) {
+    // git archive creates a clean tar from the current HEAD,
+    // excluding .git/ and respecting .gitignore
+    return execFileSync('git', ['archive', '--format=tar.gz', 'HEAD'], {
+      cwd,
+      maxBuffer: 500 * 1024 * 1024 // 500MB
+    })
+  }
+
+  // Fallback: tar with exclusions
+  const excludes = [
+    'node_modules',
+    '.git',
+    '.env',
+    '.DS_Store',
+    '*.log'
+  ]
+
+  const args = ['czf', '-', ...excludes.flatMap(e => ['--exclude', e]), '.']
+
+  return execFileSync('tar', args, {
+    cwd,
+    maxBuffer: 500 * 1024 * 1024
+  })
+}
+
+/**
+ * Check if a directory is inside a git repository.
+ */
+function isGitRepo(dir) {
+  try {
+    execFileSync('git', ['rev-parse', '--is-inside-work-tree'], {
+      cwd: dir,
+      stdio: 'pipe'
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Extract git metadata (commit, branch, message) if available.
+ */
+function getGitInfo() {
+  try {
+    const cwd = process.cwd()
+    const gitCommit = execFileSync('git', ['rev-parse', 'HEAD'], { cwd, stdio: 'pipe' })
+      .toString().trim()
+    const gitBranch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd, stdio: 'pipe' })
+      .toString().trim()
+    const gitMessage = execFileSync('git', ['log', '-1', '--pretty=%s'], { cwd, stdio: 'pipe' })
+      .toString().trim()
+    return { gitCommit, gitBranch, gitMessage }
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Watch deployment status using SSE with polling fallback
+ */
+async function watchDeployment(deploymentId) {
+  // Try SSE first
+  try {
+    return await watchDeploymentSSE(deploymentId)
+  } catch {
+    // Fall back to polling
+    return await watchDeploymentPolling(deploymentId)
+  }
+}
+
+/**
+ * Watch deployment via Server-Sent Events
+ */
+function watchDeploymentSSE(deploymentId) {
+  const { server, token } = getCredentials()
+
+  return new Promise((resolve, reject) => {
+    const controller = new AbortController()
+    let currentSpin = null
+    let lastStatus = ''
+
+    const timeout = setTimeout(() => {
+      controller.abort()
+      if (currentSpin) currentSpin.stop()
+      reject(new Error('timeout'))
+    }, 10 * 60 * 1000) // 10 minute timeout
+
+    fetch(`${server}/api/v1/deployments/${deploymentId}/stream`, {
+      headers: {
+        Accept: 'text/event-stream',
+        Authorization: `Bearer ${token}`
+      },
+      signal: controller.signal
+    })
+      .then(async (response) => {
+        if (!response.ok) {
+          throw new Error('SSE not available')
+        }
+
+        const reader = response.body.getReader()
+        const decoder = new TextDecoder()
+        let buffer = ''
+
+        currentSpin = createSpinner('Building...').start()
+
+        while (true) {
+          const { done, value } = await reader.read()
+          if (done) break
+
+          buffer += decoder.decode(value, { stream: true })
+
+          // Parse SSE events
+          const events = buffer.split('\n\n')
+          buffer = events.pop() || ''
+
+          for (const event of events) {
+            const dataMatch = event.match(/data:\s*(.+)/)
+            if (dataMatch) {
+              try {
+                const data = JSON.parse(dataMatch[1])
+
+                // Update spinner based on status
+                if (data.status !== lastStatus) {
+                  lastStatus = data.status
+                  if (currentSpin) currentSpin.stop()
+
+                  if (data.status === 'building') {
+                    currentSpin = createSpinner('Building...').start()
+                  } else if (data.status === 'deploying') {
+                    currentSpin = createSpinner('Deploying...').start()
+                  } else if (data.status === 'running' || data.status === 'failed' || data.status === 'cancelled') {
+                    clearTimeout(timeout)
+                    controller.abort()
+                    resolve({ status: data.status })
+                    return
+                  }
+                }
+
+                // Show build output if available
+                if (data.output) {
+                  if (currentSpin) currentSpin.stop()
+                  console.log(`  ${c.dim(data.output)}`)
+                  if (lastStatus === 'building' || lastStatus === 'deploying') {
+                    currentSpin = createSpinner(lastStatus === 'building' ? 'Building...' : 'Deploying...').start()
+                  }
+                }
+              } catch {
+                // Invalid JSON, ignore
+              }
+            }
+          }
+        }
+      })
+      .catch((err) => {
+        clearTimeout(timeout)
+        if (currentSpin) currentSpin.stop()
+        if (err.name !== 'AbortError') {
+          reject(err)
+        }
+      })
+  })
+}
+
+/**
+ * Watch deployment via polling (fallback)
+ */
+async function watchDeploymentPolling(deploymentId) {
+  const spin = createSpinner('Building...').start()
+  let lastStatus = ''
+
+  const maxAttempts = 300 // 10 minutes at 2s intervals
+  let attempts = 0
+
+  while (attempts < maxAttempts) {
+    await sleep(2000)
+    attempts++
+
+    try {
+      const result = await api.deployments.status(deploymentId)
+      const status = result.deployment.status
+
+      // Update spinner text based on status
+      if (status !== lastStatus) {
+        lastStatus = status
+        spin.stop()
+
+        if (status === 'building') {
+          createSpinner('Building...').start()
+        } else if (status === 'deploying') {
+          createSpinner('Deploying...').start()
+        } else if (status === 'running' || status === 'failed' || status === 'cancelled') {
+          return { status }
+        }
+      }
+    } catch {
+      // Continue polling on error
+    }
+  }
+
+  spin.stop()
+  return { status: 'timeout' }
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}

package/src/commands/terminal.js

@@ -0,0 +1,46 @@
+import { c } from '../lib/colors.js'
+import { api } from '../lib/api.js'
+import { isLoggedIn } from '../lib/config.js'
+import { error, requireProject } from '../lib/utils.js'
+
+export default async function terminal(options) {
+  if (!isLoggedIn()) {
+    error('Not logged in. Run `slipway login` first.')
+  }
+
+  const project = requireProject()
+  const environment = options.env || 'production'
+
+  try {
+    // Get environment to find container name
+    const { environment: env } = await api.environments.get(project.project, environment)
+
+    if (!env.app || env.app.length === 0) {
+      error('No app deployed in this environment. Run `slipway deploy` first.')
+    }
+
+    const app = env.app[0]
+    if (app.status !== 'running') {
+      error(`App is not running (status: ${app.status})`)
+    }
+
+    console.log()
+    console.log(`  ${c.bold(c.highlight('Terminal Access'))}`)
+    console.log(`  ${c.dim(`${project.project} / ${environment}`)}`)
+    console.log()
+    console.log(`  ${c.dim('Container:')} ${app.containerName}`)
+    console.log()
+    console.log(`  ${c.dim('To open a shell, run:')}`)
+    console.log(`    docker exec -it ${app.containerName} /bin/sh`)
+    console.log()
+    console.log(`  ${c.dim('Or for bash (if available):')}`)
+    console.log(`    docker exec -it ${app.containerName} /bin/bash`)
+    console.log()
+
+    // TODO: In a production implementation, we could:
+    // 1. Use a WebSocket to proxy the terminal session
+    // 2. Or spawn docker exec directly with inherited stdio
+  } catch (err) {
+    error(err.message)
+  }
+}

package/src/commands/whoami.js

@@ -0,0 +1,25 @@
+import { c } from '../lib/colors.js'
+import { getCredentials, isLoggedIn } from '../lib/config.js'
+import { error } from '../lib/utils.js'
+
+export default async function whoami() {
+  if (!isLoggedIn()) {
+    error('Not logged in. Run `slipway login` first.')
+  }
+
+  const { server, user, team } = getCredentials()
+
+  console.log()
+  if (user) {
+    console.log(`  ${c.dim('Email:')} ${user.email}`)
+    console.log(`  ${c.dim('Name:')} ${user.fullName}`)
+    if (team) {
+      console.log(`  ${c.dim('Team:')} ${team.name}`)
+    }
+    if (user.teamRole) {
+      console.log(`  ${c.dim('Role:')} ${user.teamRole}`)
+    }
+  }
+  console.log(`  ${c.dim('Server:')} ${server}`)
+  console.log()
+}

package/src/index.js

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+
+import { parseArgs } from 'node:util'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+import { c } from './lib/colors.js'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf8'))
+
+// Command aliases (alias → primary command)
+const aliases = {
+  deploy: 'slide',
+  launch: 'slide'
+}
+
+const commands = {
+  // Auth commands
+  login: {
+    description: 'Authenticate with your Slipway server',
+    options: { server: { type: 'string', short: 's' } }
+  },
+  logout: {
+    description: 'Clear stored credentials',
+    options: {}
+  },
+  whoami: {
+    description: 'Show current authenticated user',
+    options: {}
+  },
+
+  // Project commands
+  projects: {
+    description: 'List all projects',
+    options: {}
+  },
+  'project:update': {
+    description: 'Update a project',
+    args: '<slug>',
+    options: {
+      name: { type: 'string', short: 'n' },
+      description: { type: 'string', short: 'd' },
+      repo: { type: 'string', short: 'r' }
+    }
+  },
+  init: {
+    description: 'Initialize a new Slipway project',
+    options: { name: { type: 'string', short: 'n' } }
+  },
+  link: {
+    description: 'Link current directory to an existing project',
+    args: '<project>',
+    options: {}
+  },
+
+  // Environment commands
+  environments: {
+    description: 'List environments for the current project',
+    options: {}
+  },
+  'environment:create': {
+    description: 'Create a new environment',
+    args: '<name>',
+    options: {
+      production: { type: 'boolean', short: 'p' },
+      domain: { type: 'string', short: 'd' }
+    }
+  },
+  'environment:update': {
+    description: 'Update an environment',
+    args: '<slug>',
+    options: {
+      name: { type: 'string', short: 'n' },
+      domain: { type: 'string', short: 'd' },
+      production: { type: 'boolean', short: 'p' }
+    }
+  },
+
+  // Deployment commands
+  slide: {
+    description: 'Deploy the current project',
+    aliases: ['deploy', 'launch'],
+    options: {
+      env: { type: 'string', short: 'e', default: 'production' },
+      message: { type: 'string', short: 'm' }
+    }
+  },
+  deployments: {
+    description: 'List recent deployments',
+    options: {
+      env: { type: 'string', short: 'e' },
+      limit: { type: 'string', short: 'n', default: '10' }
+    }
+  },
+  logs: {
+    description: 'View application logs',
+    options: {
+      env: { type: 'string', short: 'e', default: 'production' },
+      follow: { type: 'boolean', short: 'f' },
+      tail: { type: 'string', short: 'n', default: '100' },
+      deployment: { type: 'string', short: 'd' }
+    }
+  },
+
+  // Database commands
+  'db:create': {
+    description: 'Create a new database service',
+    args: '<name>',
+    options: {
+      type: { type: 'string', short: 't', default: 'postgresql' },
+      version: { type: 'string', short: 'v', default: 'latest' },
+      env: { type: 'string', short: 'e', default: 'production' }
+    }
+  },
+  'db:url': {
+    description: 'Get database connection URL',
+    args: '<name>',
+    options: {
+      env: { type: 'string', short: 'e', default: 'production' }
+    }
+  },
+
+  // Service commands
+  services: {
+    description: 'List all services',
+    options: {
+      env: { type: 'string', short: 'e' }
+    }
+  },
+
+  // Environment variable commands
+  env: {
+    description: 'List environment variables',
+    options: {
+      env: { type: 'string', short: 'e', default: 'production' }
+    }
+  },
+  'env:set': {
+    description: 'Set environment variables (KEY=value)',
+    args: '<pairs...>',
+    options: {
+      env: { type: 'string', short: 'e', default: 'production' }
+    }
+  },
+  'env:unset': {
+    description: 'Remove environment variables',
+    args: '<keys...>',
+    options: {
+      env: { type: 'string', short: 'e', default: 'production' }
+    }
+  },
+
+  // Container access
+  terminal: {
+    description: 'Open a terminal session in the running container',
+    options: {
+      env: { type: 'string', short: 'e', default: 'production' }
+    }
+  },
+  run: {
+    description: 'Run a command in the container',
+    args: '<command...>',
+    options: {
+      env: { type: 'string', short: 'e', default: 'production' }
+    }
+  }
+}
+
+function showHelp() {
+  console.log()
+  console.log(`  ${c.bold(c.highlight('Slipway'))} ${c.dim(`v${pkg.version}`)}`)
+  console.log(`  ${c.dim('Deploy Sails apps with ease')}`)
+  console.log()
+  console.log('  Usage: slipway <command> [options]')
+  console.log()
+  console.log('  Commands:')
+  console.log()
+
+  // Group commands
+  const groups = {
+    'Authentication': ['login', 'logout', 'whoami'],
+    'Project': ['projects', 'project:update', 'init', 'link'],
+    'Environments': ['environments', 'environment:create', 'environment:update'],
+    'Deployment': ['slide', 'deployments', 'logs'],
+    'Database': ['db:create', 'db:url'],
+    'Services': ['services'],
+    'Env Variables': ['env', 'env:set', 'env:unset'],
+    'Container': ['terminal', 'run']
+  }
+
+  for (const [groupName, cmds] of Object.entries(groups)) {
+    console.log(`  ${c.dim(groupName)}`)
+    for (const cmd of cmds) {
+      const def = commands[cmd]
+      const args = def.args ? ` ${def.args}` : ''
+      const aliasText = def.aliases ? ` ${c.dim(`(or: ${def.aliases.join(', ')})`)}` : ''
+      console.log(`    ${c.highlight(cmd)}${c.dim(args)}${aliasText}`)
+      console.log(`      ${def.description}`)
+    }
+    console.log()
+  }
+
+  console.log('  Options:')
+  console.log(`    ${c.dim('-h, --help')}     Show help`)
+  console.log(`    ${c.dim('-v, --version')}  Show version`)
+  console.log()
+}
+
+function showVersion() {
+  console.log(`slipway v${pkg.version}`)
+}
+
+async function main() {
+  // Parse global options first
+  const { values: globalValues, positionals } = parseArgs({
+    allowPositionals: true,
+    strict: false,
+    options: {
+      help: { type: 'boolean', short: 'h' },
+      version: { type: 'boolean', short: 'v' }
+    }
+  })
+
+  if (globalValues.version) {
+    showVersion()
+    return
+  }
+
+  if (globalValues.help || positionals.length === 0) {
+    showHelp()
+    return
+  }
+
+  // Resolve aliases
+  let command = positionals[0]
+  if (aliases[command]) {
+    command = aliases[command]
+  }
+
+  const commandDef = commands[command]
+
+  if (!commandDef) {
+    console.error(`${c.error('Error:')} Unknown command: ${positionals[0]}`)
+    console.error(`Run ${c.highlight('slipway --help')} for available commands.`)
+    process.exit(1)
+  }
+
+  // Parse command-specific options
+  const commandArgs = process.argv.slice(3) // Skip node, script, command
+  let parsed
+
+  try {
+    parsed = parseArgs({
+      args: commandArgs,
+      allowPositionals: true,
+      options: {
+        ...commandDef.options,
+        help: { type: 'boolean', short: 'h' }
+      }
+    })
+  } catch (err) {
+    console.error(`${c.error('Error:')} ${err.message}`)
+    process.exit(1)
+  }
+
+  if (parsed.values.help) {
+    console.log()
+    console.log(`  ${c.bold(command)}${commandDef.args ? ` ${c.dim(commandDef.args)}` : ''}`)
+    if (commandDef.aliases) {
+      console.log(`  ${c.dim(`Aliases: ${commandDef.aliases.join(', ')}`)}`)
+    }
+    console.log(`  ${commandDef.description}`)
+    console.log()
+    if (Object.keys(commandDef.options).length > 0) {
+      console.log('  Options:')
+      for (const [name, opt] of Object.entries(commandDef.options)) {
+        const short = opt.short ? `-${opt.short}, ` : '    '
+        const def = opt.default ? ` (default: ${opt.default})` : ''
+        console.log(`    ${short}--${name}${def}`)
+      }
+      console.log()
+    }
+    return
+  }
+
+  // Apply defaults
+  const options = { ...parsed.values }
+  for (const [name, opt] of Object.entries(commandDef.options)) {
+    if (options[name] === undefined && opt.default !== undefined) {
+      options[name] = opt.default
+    }
+  }
+
+  // Map command to file name (handle colons)
+  const commandFile = command.replace(':', '-')
+
+  try {
+    const module = await import(`./commands/${commandFile}.js`)
+    await module.default(options, parsed.positionals)
+  } catch (err) {
+    if (err.code === 'ERR_MODULE_NOT_FOUND') {
+      console.error(`${c.error('Error:')} Command '${command}' is not yet implemented.`)
+      process.exit(1)
+    }
+    throw err
+  }
+}
+
+main().catch((err) => {
+  console.error(`${c.error('Error:')} ${err.message}`)
+  process.exit(1)
+})