slipway-cli 0.0.0

package/src/lib/api.js

@@ -0,0 +1,136 @@
+import { getCredentials, isLoggedIn } from './config.js'
+
+export class APIError extends Error {
+  constructor(message, statusCode, body) {
+    super(message)
+    this.name = 'APIError'
+    this.statusCode = statusCode
+    this.body = body
+  }
+}
+
+async function apiRequest(method, path, options = {}) {
+  if (!isLoggedIn()) {
+    throw new Error('Not logged in. Run `slipway login` first.')
+  }
+
+  const { server, token } = getCredentials()
+  const url = `${server}/api/v1${path}`
+
+  const headers = {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${token}`
+  }
+
+  const fetchOptions = {
+    method,
+    headers
+  }
+
+  if (options.body) {
+    fetchOptions.body = JSON.stringify(options.body)
+  }
+
+  try {
+    const response = await fetch(url, fetchOptions)
+    const body = await response.json()
+
+    if (!response.ok) {
+      const message = body.message || body.error || `Request failed with status ${response.status}`
+      throw new APIError(message, response.status, body)
+    }
+
+    return body
+  } catch (error) {
+    if (error instanceof APIError) {
+      throw error
+    }
+    throw new Error(`Failed to connect to Slipway server: ${error.message}`)
+  }
+}
+
+/**
+ * Upload a file as multipart form data.
+ * Used by `slipway slide` to push source tarballs.
+ */
+async function apiUpload(path, fieldName, buffer, filename) {
+  if (!isLoggedIn()) {
+    throw new Error('Not logged in. Run `slipway login` first.')
+  }
+
+  const { server, token } = getCredentials()
+  const url = `${server}/api/v1${path}`
+
+  const formData = new FormData()
+  formData.append(fieldName, new Blob([buffer]), filename)
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`
+      },
+      body: formData
+    })
+
+    const body = await response.json()
+
+    if (!response.ok) {
+      const message = body.message || body.error || `Upload failed with status ${response.status}`
+      throw new APIError(message, response.status, body)
+    }
+
+    return body
+  } catch (error) {
+    if (error instanceof APIError) {
+      throw error
+    }
+    throw new Error(`Failed to upload to Slipway server: ${error.message}`)
+  }
+}
+
+// Convenience methods
+export const api = {
+  get: (path) => apiRequest('GET', path),
+  post: (path, body) => apiRequest('POST', path, { body }),
+  patch: (path, body) => apiRequest('PATCH', path, { body }),
+  delete: (path) => apiRequest('DELETE', path),
+  upload: apiUpload
+}
+
+// Project endpoints
+api.projects = {
+  list: () => api.get('/projects'),
+  create: (data) => api.post('/projects', data),
+  get: (id) => api.get(`/projects/${id}`),
+  update: (id, data) => api.patch(`/projects/${id}`, data),
+  delete: (id) => api.delete(`/projects/${id}`),
+  push: (id, tarballBuffer) => api.upload(`/projects/${id}/push`, 'source', tarballBuffer, 'source.tar.gz')
+}
+
+// Environment endpoints
+api.environments = {
+  list: (projectId) => api.get(`/projects/${projectId}/environments`),
+  create: (projectId, data) => api.post(`/projects/${projectId}/environments`, data),
+  get: (projectId, id) => api.get(`/projects/${projectId}/environments/${id}`),
+  update: (projectId, id, data) => api.patch(`/projects/${projectId}/environments/${id}`, data),
+  delete: (projectId, id) => api.delete(`/projects/${projectId}/environments/${id}`)
+}
+
+// Deployment endpoints
+api.deployments = {
+  trigger: (projectId, environmentId, data) =>
+    api.post(`/projects/${projectId}/environments/${environmentId}/deploy`, data),
+  status: (id) => api.get(`/deployments/${id}`),
+  logs: (id, type = 'all') => api.get(`/deployments/${id}/logs?type=${type}`)
+}
+
+// Service endpoints
+api.services = {
+  list: (projectId, environmentId) =>
+    api.get(`/projects/${projectId}/environments/${environmentId}/services`),
+  create: (projectId, environmentId, data) =>
+    api.post(`/projects/${projectId}/environments/${environmentId}/services`, data),
+  get: (id) => api.get(`/services/${id}`),
+  delete: (id) => api.delete(`/services/${id}`)
+}

package/src/lib/colors.js

@@ -0,0 +1,30 @@
+// ANSI color codes
+const codes = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+  gray: '\x1b[90m',
+  // Slipway brand color (teal-ish)
+  slipway: '\x1b[38;2;20;184;166m',
+  bgSlipway: '\x1b[48;2;20;184;166m'
+}
+
+export const c = {
+  error: (s) => `${codes.red}${s}${codes.reset}`,
+  success: (s) => `${codes.green}${s}${codes.reset}`,
+  warn: (s) => `${codes.yellow}${s}${codes.reset}`,
+  info: (s) => `${codes.cyan}${s}${codes.reset}`,
+  dim: (s) => `${codes.dim}${s}${codes.reset}`,
+  bold: (s) => `${codes.bold}${s}${codes.reset}`,
+  gray: (s) => `${codes.gray}${s}${codes.reset}`,
+  highlight: (s) => `${codes.slipway}${s}${codes.reset}`,
+  brand: (s) => `${codes.bgSlipway}${codes.white}${codes.bold} ${s} ${codes.reset}`
+}
+
+export default c

package/src/lib/config.js

@@ -0,0 +1,72 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+// Global config stored in ~/.slipway/config.json
+const CONFIG_DIR = join(homedir(), '.slipway')
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json')
+
+// Project config stored in .slipway.json in the project directory
+export const PROJECT_CONFIG_FILE = '.slipway.json'
+
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true })
+  }
+}
+
+function readConfig() {
+  ensureConfigDir()
+  if (!existsSync(CONFIG_FILE)) {
+    return { server: '', token: '', user: null, team: null }
+  }
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf8'))
+  } catch {
+    return { server: '', token: '', user: null, team: null }
+  }
+}
+
+function writeConfig(config) {
+  ensureConfigDir()
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2))
+}
+
+export function getProjectConfig() {
+  const configPath = join(process.cwd(), PROJECT_CONFIG_FILE)
+  if (!existsSync(configPath)) {
+    return null
+  }
+  try {
+    return JSON.parse(readFileSync(configPath, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+export function saveProjectConfig(projectConfig) {
+  const configPath = join(process.cwd(), PROJECT_CONFIG_FILE)
+  writeFileSync(configPath, JSON.stringify(projectConfig, null, 2) + '\n')
+}
+
+export function isLoggedIn() {
+  const config = readConfig()
+  return Boolean(config.token && config.server)
+}
+
+export function getCredentials() {
+  return readConfig()
+}
+
+export function setCredentials({ server, token, user, team }) {
+  const config = readConfig()
+  if (server) config.server = server
+  if (token) config.token = token
+  if (user) config.user = user
+  if (team) config.team = team
+  writeConfig(config)
+}
+
+export function clearCredentials() {
+  writeConfig({ server: '', token: '', user: null, team: null })
+}

package/src/lib/prompt.js

@@ -0,0 +1,102 @@
+import { createInterface } from 'node:readline'
+
+export function prompt(question, defaultValue = '') {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  const suffix = defaultValue ? ` (${defaultValue})` : ''
+
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      rl.close()
+      resolve(answer.trim() || defaultValue)
+    })
+  })
+}
+
+export function promptPassword(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  return new Promise((resolve) => {
+    // Hide input for password
+    process.stdout.write(`${question}: `)
+
+    const stdin = process.stdin
+    const wasRaw = stdin.isRaw
+
+    if (stdin.isTTY) {
+      stdin.setRawMode(true)
+    }
+
+    let password = ''
+
+    const onData = (char) => {
+      char = char.toString()
+
+      switch (char) {
+        case '\n':
+        case '\r':
+        case '\u0004': // Ctrl+D
+          if (stdin.isTTY) {
+            stdin.setRawMode(wasRaw)
+          }
+          stdin.removeListener('data', onData)
+          rl.close()
+          process.stdout.write('\n')
+          resolve(password)
+          break
+        case '\u0003': // Ctrl+C
+          process.exit(1)
+          break
+        case '\u007F': // Backspace
+          password = password.slice(0, -1)
+          break
+        default:
+          password += char
+          break
+      }
+    }
+
+    stdin.on('data', onData)
+  })
+}
+
+export function confirm(question, defaultValue = true) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  const suffix = defaultValue ? ' (Y/n)' : ' (y/N)'
+
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      rl.close()
+      const normalized = answer.trim().toLowerCase()
+      if (normalized === '') {
+        resolve(defaultValue)
+      } else {
+        resolve(normalized === 'y' || normalized === 'yes')
+      }
+    })
+  })
+}
+
+export function waitForEnter(message = 'Press ENTER to continue...') {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+
+  return new Promise((resolve) => {
+    rl.question(message, () => {
+      rl.close()
+      resolve()
+    })
+  })
+}

package/src/lib/sse.js

@@ -0,0 +1,102 @@
+import { getCredentials } from './config.js'
+
+/**
+ * Connect to a Server-Sent Events endpoint
+ *
+ * @param {string} path - API path (e.g., '/cli/auth/stream')
+ * @param {object} options - Options
+ * @param {function} options.onMessage - Called for each message
+ * @param {function} options.onError - Called on error
+ * @param {function} options.onClose - Called when stream closes
+ * @returns {function} - Call to abort the connection
+ */
+export function connectSSE(path, { onMessage, onError, onClose }) {
+  const { server, token } = getCredentials()
+  const url = `${server}/api/v1${path}`
+
+  const controller = new AbortController()
+
+  ;(async () => {
+    try {
+      const response = await fetch(url, {
+        headers: {
+          Accept: 'text/event-stream',
+          Authorization: token ? `Bearer ${token}` : undefined
+        },
+        signal: controller.signal
+      })
+
+      if (!response.ok) {
+        throw new Error(`SSE connection failed: ${response.status}`)
+      }
+
+      const reader = response.body.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ''
+
+      while (true) {
+        const { done, value } = await reader.read()
+
+        if (done) {
+          if (onClose) onClose()
+          break
+        }
+
+        buffer += decoder.decode(value, { stream: true })
+
+        // Parse SSE format: "event: type\ndata: json\n\n"
+        const lines = buffer.split('\n')
+        buffer = ''
+
+        let eventType = 'message'
+        let eventData = null
+
+        for (const line of lines) {
+          if (line.startsWith('event:')) {
+            eventType = line.slice(6).trim()
+          } else if (line.startsWith('data:')) {
+            const dataStr = line.slice(5).trim()
+            try {
+              eventData = JSON.parse(dataStr)
+            } catch {
+              eventData = dataStr
+            }
+          } else if (line === '' && eventData !== null) {
+            // Empty line means end of event
+            if (onMessage) {
+              onMessage(eventType, eventData)
+            }
+            eventType = 'message'
+            eventData = null
+          } else if (line !== '') {
+            // Incomplete event, save for next chunk
+            buffer = line
+          }
+        }
+      }
+    } catch (err) {
+      if (err.name === 'AbortError') {
+        if (onClose) onClose()
+      } else {
+        if (onError) onError(err)
+      }
+    }
+  })()
+
+  // Return abort function
+  return () => controller.abort()
+}
+
+/**
+ * Subscribe to deployment status updates
+ */
+export function subscribeToDeployment(deploymentId, callbacks) {
+  return connectSSE(`/deployments/${deploymentId}/stream`, callbacks)
+}
+
+/**
+ * Subscribe to CLI auth confirmation
+ */
+export function subscribeToAuthConfirmation(code, callbacks) {
+  return connectSSE(`/cli/auth/stream?code=${code}`, callbacks)
+}

package/src/lib/utils.js

@@ -0,0 +1,122 @@
+import { c } from './colors.js'
+import { getProjectConfig } from './config.js'
+
+export function error(message) {
+  console.error(`${c.error('Error:')} ${message}`)
+  process.exit(1)
+}
+
+export function warn(message) {
+  console.warn(`${c.warn('Warning:')} ${message}`)
+}
+
+export function success(message) {
+  console.log(`${c.success('✓')} ${message}`)
+}
+
+export function info(message) {
+  console.log(`${c.info('ℹ')} ${message}`)
+}
+
+export function requireProject() {
+  const project = getProjectConfig()
+  if (!project) {
+    error('No Slipway project found. Run `slipway init` or `slipway link <project>` first.')
+  }
+  return project
+}
+
+export function formatDate(timestamp) {
+  if (!timestamp) return 'N/A'
+  const date = new Date(timestamp)
+  return date.toLocaleString()
+}
+
+export function formatDuration(seconds) {
+  if (!seconds) return 'N/A'
+  if (seconds < 60) return `${seconds}s`
+  const minutes = Math.floor(seconds / 60)
+  const secs = seconds % 60
+  return `${minutes}m ${secs}s`
+}
+
+export function statusColor(status) {
+  const colorMap = {
+    running: c.success,
+    pending: c.warn,
+    building: c.info,
+    deploying: c.info,
+    stopped: c.gray,
+    failed: c.error,
+    cancelled: c.gray
+  }
+  const colorFn = colorMap[status] || ((s) => s)
+  return colorFn(status)
+}
+
+// Simple spinner using stdout
+export function createSpinner(text) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+  let i = 0
+  let interval = null
+
+  return {
+    start() {
+      process.stdout.write(`\r${c.info(frames[0])} ${text}`)
+      interval = setInterval(() => {
+        i = (i + 1) % frames.length
+        process.stdout.write(`\r${c.info(frames[i])} ${text}`)
+      }, 80)
+      return this
+    },
+    stop(finalText) {
+      if (interval) {
+        clearInterval(interval)
+        interval = null
+      }
+      process.stdout.write('\r' + ' '.repeat(text.length + 4) + '\r')
+      if (finalText) console.log(finalText)
+      return this
+    },
+    succeed(msg) {
+      return this.stop(`${c.success('✓')} ${msg}`)
+    },
+    fail(msg) {
+      return this.stop(`${c.error('✗')} ${msg}`)
+    }
+  }
+}
+
+// Alias for backwards compatibility
+export function spinner(text) {
+  return createSpinner(text).start()
+}
+
+// Simple table display
+export function table(headers, rows) {
+  // Calculate column widths
+  const widths = headers.map((h, i) => {
+    const colValues = [h, ...rows.map(r => String(r[i] || ''))]
+    return Math.max(...colValues.map(v => stripAnsi(v).length))
+  })
+
+  // Print header
+  const headerRow = headers.map((h, i) => h.padEnd(widths[i])).join('  ')
+  console.log(`  ${c.dim(headerRow)}`)
+  console.log(`  ${c.dim('─'.repeat(headerRow.length))}`)
+
+  // Print rows
+  for (const row of rows) {
+    const rowStr = row.map((cell, i) => {
+      const str = String(cell || '')
+      const padding = widths[i] - stripAnsi(str).length
+      return str + ' '.repeat(Math.max(0, padding))
+    }).join('  ')
+    console.log(`  ${rowStr}`)
+  }
+}
+
+// Strip ANSI codes for length calculation
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, '')
+}