slipway-cli 0.0.0 → 0.0.2

package/README.md

@@ -17,10 +17,10 @@ This means instant startup, no supply chain risk, and zero maintenance overhead.
 ## Commands
 
 ```bash
-# Deploy (slide into production!)
+# Slide into production!
 slipway slide                    # Primary command
-slipway launch                   # Alias
 slipway deploy                   # Alias
+slipway launch                   # Alias
 
 # Apps
 slipway app:create myapp
@@ -53,9 +53,9 @@ slipway dev                      # Local dev mode
 ## Installation
 
 ```bash
-npm install -g slipway
+npm install -g slipway-cli
 # or
-npx slipway
+npx slipway-cli
 ```
 
 ## Part of the Slipway Suite

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slipway-cli",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "description": "CLI for Slipway - Deploy Sails apps with ease",
   "type": "module",
   "bin": {

package/src/commands/audit-log.js

@@ -0,0 +1,54 @@
+import { c } from '../lib/colors.js'
+import { api } from '../lib/api.js'
+import { isLoggedIn } from '../lib/config.js'
+import { error, createSpinner, table, formatDate } from '../lib/utils.js'
+
+export default async function auditLog(options) {
+  if (!isLoggedIn()) {
+    error('Not logged in. Run `slipway login` first.')
+  }
+
+  const page = parseInt(options.page, 10) || 1
+  const limit = parseInt(options.limit, 10) || 20
+
+  const spin = createSpinner('Fetching audit logs...').start()
+
+  try {
+    const { logs, pagination } = await api.auditLogs.list(page, limit)
+
+    spin.stop()
+
+    console.log()
+    console.log(`  ${c.bold(c.highlight('Audit Log'))} ${c.dim(`— page ${pagination.page} of ${pagination.totalPages}`)}`)
+    console.log()
+
+    if (!logs || logs.length === 0) {
+      console.log(`  ${c.dim('No audit log entries found.')}`)
+      console.log()
+      return
+    }
+
+    const rows = logs.map(log => [
+      formatDate(log.createdAt),
+      log.action,
+      log.resourceType,
+      log.userName,
+      log.ipAddress || 'N/A'
+    ])
+
+    table(
+      ['Date', 'Action', 'Resource', 'User', 'IP'],
+      rows
+    )
+
+    if (pagination.page < pagination.totalPages) {
+      console.log()
+      console.log(`  ${c.dim('Next page:')} ${c.highlight(`slipway audit-log --page ${pagination.page + 1}`)}`)
+    }
+
+    console.log()
+  } catch (err) {
+    spin.fail('Failed to fetch audit logs')
+    error(err.message)
+  }
+}

package/src/commands/backup-create.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, createSpinner } from '../lib/utils.js'
+
+export default async function backupCreate(options, positionals) {
+  if (!isLoggedIn()) {
+    error('Not logged in. Run `slipway login` first.')
+  }
+
+  const name = positionals[0]
+  if (!name) {
+    error('Please provide a service name. Usage: slipway backup:create <service-name>')
+  }
+
+  const project = requireProject()
+  const environment = options.env || 'production'
+
+  const spin = createSpinner('Creating backup...').start()
+
+  try {
+    // Resolve service name to ID
+    const { services } = await api.services.list(project.project, environment)
+    const service = services.find(s => s.name === name)
+
+    if (!service) {
+      spin.fail('Service not found')
+      error(`No service named "${name}" found in ${environment} environment.`)
+    }
+
+    const { backup } = await api.backups.create(service.id)
+
+    spin.succeed('Backup created')
+
+    console.log()
+    console.log(`  ${c.dim('Backup ID:')}  ${backup.id}`)
+    console.log(`  ${c.dim('Status:')}     ${backup.status}`)
+    console.log(`  ${c.dim('Type:')}       ${backup.type}`)
+    console.log()
+    console.log(`  ${c.dim('Run')} ${c.highlight(`slipway backup:list ${name}`)} ${c.dim('to check progress.')}`)
+    console.log()
+  } catch (err) {
+    spin.fail('Failed to create backup')
+    error(err.message)
+  }
+}

package/src/commands/backup-list.js

@@ -0,0 +1,65 @@
+import { c } from '../lib/colors.js'
+import { api } from '../lib/api.js'
+import { isLoggedIn } from '../lib/config.js'
+import { error, requireProject, createSpinner, table, formatDate, formatBytes, formatDuration, statusColor } from '../lib/utils.js'
+
+export default async function backupList(options, positionals) {
+  if (!isLoggedIn()) {
+    error('Not logged in. Run `slipway login` first.')
+  }
+
+  const name = positionals[0]
+  if (!name) {
+    error('Please provide a service name. Usage: slipway backup:list <service-name>')
+  }
+
+  const project = requireProject()
+  const environment = options.env || 'production'
+
+  const spin = createSpinner('Fetching backups...').start()
+
+  try {
+    // Resolve service name to ID
+    const { services } = await api.services.list(project.project, environment)
+    const service = services.find(s => s.name === name)
+
+    if (!service) {
+      spin.fail('Service not found')
+      error(`No service named "${name}" found in ${environment} environment.`)
+    }
+
+    const { backups } = await api.backups.list(service.id)
+
+    spin.stop()
+
+    console.log()
+    console.log(`  ${c.bold(c.highlight('Backups'))} ${c.dim(`— ${name} (${environment})`)}`)
+    console.log()
+
+    if (!backups || backups.length === 0) {
+      console.log(`  ${c.dim('No backups found.')}`)
+      console.log(`  ${c.dim('Run')} ${c.highlight(`slipway backup:create ${name}`)} ${c.dim('to create one.')}`)
+      console.log()
+      return
+    }
+
+    const rows = backups.map(b => [
+      b.id,
+      statusColor(b.status),
+      b.type,
+      formatBytes(b.sizeBytes),
+      b.durationMs ? formatDuration(Math.round(b.durationMs / 1000)) : 'N/A',
+      formatDate(b.createdAt)
+    ])
+
+    table(
+      ['ID', 'Status', 'Type', 'Size', 'Duration', 'Date'],
+      rows
+    )
+
+    console.log()
+  } catch (err) {
+    spin.fail('Failed to fetch backups')
+    error(err.message)
+  }
+}

package/src/commands/backup-restore.js

@@ -0,0 +1,25 @@
+import { api } from '../lib/api.js'
+import { isLoggedIn } from '../lib/config.js'
+import { error, createSpinner } from '../lib/utils.js'
+
+export default async function backupRestore(options, positionals) {
+  if (!isLoggedIn()) {
+    error('Not logged in. Run `slipway login` first.')
+  }
+
+  const backupId = positionals[0]
+  if (!backupId) {
+    error('Please provide a backup ID. Usage: slipway backup:restore <backup-id>')
+  }
+
+  const spin = createSpinner('Starting restore...').start()
+
+  try {
+    const result = await api.backups.restore(backupId)
+
+    spin.succeed(`Restore started for backup ${result.backupId}`)
+  } catch (err) {
+    spin.fail('Failed to start restore')
+    error(err.message)
+  }
+}

package/src/commands/deployments.js

@@ -47,12 +47,12 @@ export default async function deployments(options) {
     const limited = allDeployments.slice(0, parseInt(options.limit) || 10)
 
     if (limited.length === 0) {
-      console.log(`  ${c.dim('No deployments yet. Run `slipway deploy` to create one.')}`)
+      console.log(`  ${c.dim('No deployments yet. Run `slipway slide` to create one.')}`)
       return
     }
 
     const rows = limited.map(d => [
-      d.id.substring(0, 8),
+      String(d.id),
       statusColor(d.status),
       d.environment,
       d.gitBranch || '-',

package/src/commands/env-set.js

@@ -54,7 +54,7 @@ export default async function envSet(options, positionals) {
     }
 
     console.log()
-    console.log(`  ${c.dim('Run')} ${c.highlight('slipway deploy')} ${c.dim('to apply changes.')}`)
+    console.log(`  ${c.dim('Run')} ${c.highlight('slipway slide')} ${c.dim('to apply changes.')}`)
     console.log()
   } catch (err) {
     spin.fail('Failed to set environment variables')

package/src/commands/env-unset.js

@@ -53,7 +53,7 @@ export default async function envUnset(options, positionals) {
     }
 
     console.log()
-    console.log(`  ${c.dim('Run')} ${c.highlight('slipway deploy')} ${c.dim('to apply changes.')}`)
+    console.log(`  ${c.dim('Run')} ${c.highlight('slipway slide')} ${c.dim('to apply changes.')}`)
     console.log()
   } catch (err) {
     spin.fail('Failed to remove environment variables')

package/src/commands/link.js

@@ -31,7 +31,7 @@ export default async function link(options, positionals) {
     console.log(`  ${c.dim('Project:')} ${project.name}`)
     console.log(`  ${c.dim('Slug:')} ${project.slug}`)
     console.log()
-    console.log(`  ${c.dim('Run')} ${c.highlight('slipway deploy')} ${c.dim('to deploy your app.')}`)
+    console.log(`  ${c.dim('Run')} ${c.highlight('slipway slide')} ${c.dim('to deploy your app.')}`)
     console.log()
   } catch (err) {
     spin.fail('Failed to link project')

package/src/commands/logs.js

@@ -25,11 +25,18 @@ export default async function logs(options) {
     // 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 apps = env.app || []
+    if (apps.length === 0) {
+      error('No app deployed in this environment. Run `slipway slide` first.')
     }
 
-    const app = env.app[0]
+    const app = options.app
+      ? apps.find(a => a.slug === options.app)
+      : apps.find(a => a.isDefault) || apps[0]
+
+    if (!app) {
+      error(`App "${options.app}" not found. Available: ${apps.map(a => a.slug).join(', ')}`)
+    }
     if (app.status !== 'running') {
       error(`App is not running (status: ${app.status})`)
     }

package/src/commands/push.js

@@ -0,0 +1,94 @@
+import { execFileSync } from 'node:child_process'
+import { c } from '../lib/colors.js'
+import { api } from '../lib/api.js'
+import { isLoggedIn } from '../lib/config.js'
+import { error, requireProject, createSpinner } from '../lib/utils.js'
+
+export default async function push(options) {
+  if (!isLoggedIn()) {
+    error('Not logged in. Run `slipway login` first.')
+  }
+
+  const project = requireProject()
+
+  console.log()
+  console.log(`  ${c.bold(c.highlight('Pushing'))} ${project.project}`)
+  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)
+  }
+
+  console.log()
+  console.log(`  ${c.success('✓')} Source code updated`)
+  console.log()
+  console.log(`  ${c.dim('To deploy, run:')} ${c.highlight('slipway slide')}`)
+  console.log()
+}
+
+/**
+ * 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()
+
+  if (isGitRepo(cwd)) {
+    return execFileSync('git', ['archive', '--format=tar.gz', 'HEAD'], {
+      cwd,
+      maxBuffer: 500 * 1024 * 1024
+    })
+  }
+
+  // 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
+  }
+}

package/src/commands/run.js

@@ -20,11 +20,18 @@ export default async function runCommand(options, positionals) {
     // 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 apps = env.app || []
+    if (apps.length === 0) {
+      error('No app deployed in this environment. Run `slipway slide` first.')
     }
 
-    const app = env.app[0]
+    const app = options.app
+      ? apps.find(a => a.slug === options.app)
+      : apps.find(a => a.isDefault) || apps[0]
+
+    if (!app) {
+      error(`App "${options.app}" not found. Available: ${apps.map(a => a.slug).join(', ')}`)
+    }
     if (app.status !== 'running') {
       error(`App is not running (status: ${app.status})`)
     }

package/src/commands/slide.js

@@ -4,6 +4,56 @@ import { api } from '../lib/api.js'
 import { isLoggedIn, getCredentials } from '../lib/config.js'
 import { error, requireProject, createSpinner } from '../lib/utils.js'
 
+const maritimeMessages = {
+  pending: [
+    'Waiting for the tide...',
+    'Checking the compass...',
+    'Reading the stars...',
+    'Gathering the crew...',
+  ],
+  building: [
+    'Hoisting the sails...',
+    'Loading the cargo...',
+    'Checking the rigging...',
+    'Swabbing the deck...',
+    'Tying the knots...',
+    'Hammering the hull...',
+  ],
+  pushing: [
+    'Signaling the fleet...',
+    'Sending up a flare...',
+    'Raising the flag...',
+  ],
+  deploying: [
+    'Charting the course...',
+    'Setting sail...',
+    'Catching the wind...',
+    'Navigating the waters...',
+    'Full speed ahead...',
+    'Approaching the harbor...',
+  ],
+}
+
+const statusLabels = {
+  pending: 'Waiting',
+  building: 'Building',
+  pushing: 'Pushing',
+  deploying: 'Deploying',
+}
+
+function createMessageRotator(spinner, status) {
+  const messages = maritimeMessages[status]
+  if (!messages) return null
+  let index = 0
+  const label = statusLabels[status] || status
+  spinner.setText(`${label} — ${c.dim(messages[0])}`)
+  index = 1
+  return setInterval(() => {
+    spinner.setText(`${label} — ${c.dim(messages[index % messages.length])}`)
+    index++
+  }, 4000)
+}
+
 export default async function slide(options) {
   if (!isLoggedIn()) {
     error('Not logged in. Run `slipway login` first.')
@@ -49,13 +99,14 @@ export default async function slide(options) {
       environment,
       {
         message: options.message,
+        appSlug: options.app,
         ...getGitInfo()
       }
     )
 
     deploySpin.succeed('Deployment started')
     console.log()
-    console.log(`  ${c.dim('Deployment ID:')} ${deployment.id.substring(0, 8)}`)
+    console.log(`  ${c.dim('Deployment ID:')} ${deployment.id}`)
     console.log()
 
     // 4. Watch deployment status via SSE (with polling fallback)
@@ -78,7 +129,7 @@ export default async function slide(options) {
     } 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(`  ${c.dim('Run')} ${c.highlight(`slipway logs -d ${deployment.id}`)} ${c.dim('to view logs.')}`)
       console.log()
       process.exit(1)
     } else {
@@ -182,9 +233,11 @@ function watchDeploymentSSE(deploymentId) {
     const controller = new AbortController()
     let currentSpin = null
     let lastStatus = ''
+    let messageRotatorInterval = null
 
     const timeout = setTimeout(() => {
       controller.abort()
+      if (messageRotatorInterval) clearInterval(messageRotatorInterval)
       if (currentSpin) currentSpin.stop()
       reject(new Error('timeout'))
     }, 10 * 60 * 1000) // 10 minute timeout
@@ -206,6 +259,7 @@ function watchDeploymentSSE(deploymentId) {
         let buffer = ''
 
         currentSpin = createSpinner('Building...').start()
+        messageRotatorInterval = createMessageRotator(currentSpin, 'building')
 
         while (true) {
           const { done, value } = await reader.read()
@@ -226,12 +280,12 @@ function watchDeploymentSSE(deploymentId) {
                 // Update spinner based on status
                 if (data.status !== lastStatus) {
                   lastStatus = data.status
+                  if (messageRotatorInterval) clearInterval(messageRotatorInterval)
                   if (currentSpin) currentSpin.stop()
 
-                  if (data.status === 'building') {
-                    currentSpin = createSpinner('Building...').start()
-                  } else if (data.status === 'deploying') {
-                    currentSpin = createSpinner('Deploying...').start()
+                  if (['building', 'pushing', 'deploying'].includes(data.status)) {
+                    currentSpin = createSpinner('...').start()
+                    messageRotatorInterval = createMessageRotator(currentSpin, data.status)
                   } else if (data.status === 'running' || data.status === 'failed' || data.status === 'cancelled') {
                     clearTimeout(timeout)
                     controller.abort()
@@ -242,10 +296,12 @@ function watchDeploymentSSE(deploymentId) {
 
                 // Show build output if available
                 if (data.output) {
+                  if (messageRotatorInterval) clearInterval(messageRotatorInterval)
                   if (currentSpin) currentSpin.stop()
                   console.log(`  ${c.dim(data.output)}`)
-                  if (lastStatus === 'building' || lastStatus === 'deploying') {
-                    currentSpin = createSpinner(lastStatus === 'building' ? 'Building...' : 'Deploying...').start()
+                  if (['building', 'pushing', 'deploying'].includes(lastStatus)) {
+                    currentSpin = createSpinner('...').start()
+                    messageRotatorInterval = createMessageRotator(currentSpin, lastStatus)
                   }
                 }
               } catch {
@@ -254,9 +310,20 @@ function watchDeploymentSSE(deploymentId) {
             }
           }
         }
+
+        // Stream ended — resolve with last known status or fall back to polling
+        clearTimeout(timeout)
+        if (messageRotatorInterval) clearInterval(messageRotatorInterval)
+        if (currentSpin) currentSpin.stop()
+        if (lastStatus && ['running', 'failed', 'cancelled'].includes(lastStatus)) {
+          resolve({ status: lastStatus })
+        } else {
+          reject(new Error('Stream ended before deployment completed'))
+        }
       })
       .catch((err) => {
         clearTimeout(timeout)
+        if (messageRotatorInterval) clearInterval(messageRotatorInterval)
         if (currentSpin) currentSpin.stop()
         if (err.name !== 'AbortError') {
           reject(err)
@@ -271,6 +338,7 @@ function watchDeploymentSSE(deploymentId) {
 async function watchDeploymentPolling(deploymentId) {
   const spin = createSpinner('Building...').start()
   let lastStatus = ''
+  let messageRotatorInterval = createMessageRotator(spin, 'building')
 
   const maxAttempts = 300 // 10 minutes at 2s intervals
   let attempts = 0
@@ -286,13 +354,12 @@ async function watchDeploymentPolling(deploymentId) {
       // Update spinner text based on status
       if (status !== lastStatus) {
         lastStatus = status
-        spin.stop()
+        if (messageRotatorInterval) clearInterval(messageRotatorInterval)
 
-        if (status === 'building') {
-          createSpinner('Building...').start()
-        } else if (status === 'deploying') {
-          createSpinner('Deploying...').start()
+        if (['building', 'pushing', 'deploying'].includes(status)) {
+          messageRotatorInterval = createMessageRotator(spin, status)
         } else if (status === 'running' || status === 'failed' || status === 'cancelled') {
+          spin.stop()
           return { status }
         }
       }
@@ -301,6 +368,7 @@ async function watchDeploymentPolling(deploymentId) {
     }
   }
 
+  if (messageRotatorInterval) clearInterval(messageRotatorInterval)
   spin.stop()
   return { status: 'timeout' }
 }

package/src/commands/terminal.js

@@ -15,11 +15,18 @@ export default async function terminal(options) {
     // 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 apps = env.app || []
+    if (apps.length === 0) {
+      error('No app deployed in this environment. Run `slipway slide` first.')
     }
 
-    const app = env.app[0]
+    const app = options.app
+      ? apps.find(a => a.slug === options.app)
+      : apps.find(a => a.isDefault) || apps[0]
+
+    if (!app) {
+      error(`App "${options.app}" not found. Available: ${apps.map(a => a.slug).join(', ')}`)
+    }
     if (app.status !== 'running') {
       error(`App is not running (status: ${app.status})`)
     }

package/src/index.js

@@ -78,11 +78,16 @@ const commands = {
   },
 
   // Deployment commands
+  push: {
+    description: 'Push source code without deploying',
+    options: {}
+  },
   slide: {
-    description: 'Deploy the current project',
+    description: 'Push and deploy the current project',
     aliases: ['deploy', 'launch'],
     options: {
       env: { type: 'string', short: 'e', default: 'production' },
+      app: { type: 'string', short: 'a' },
       message: { type: 'string', short: 'm' }
     }
   },
@@ -97,6 +102,7 @@ const commands = {
     description: 'View application logs',
     options: {
       env: { type: 'string', short: 'e', default: 'production' },
+      app: { type: 'string', short: 'a' },
       follow: { type: 'boolean', short: 'f' },
       tail: { type: 'string', short: 'n', default: '100' },
       deployment: { type: 'string', short: 'd' }
@@ -151,18 +157,46 @@ const commands = {
     }
   },
 
+  // Backup commands
+  'backup:create': {
+    description: 'Create a manual database backup',
+    args: '<service-name>',
+    options: { env: { type: 'string', short: 'e', default: 'production' } }
+  },
+  'backup:list': {
+    description: 'List backups for a database service',
+    args: '<service-name>',
+    options: { env: { type: 'string', short: 'e', default: 'production' } }
+  },
+  'backup:restore': {
+    description: 'Restore a database backup',
+    args: '<backup-id>',
+    options: {}
+  },
+
+  // Admin commands
+  'audit-log': {
+    description: 'View audit log entries',
+    options: {
+      page: { type: 'string', short: 'p', default: '1' },
+      limit: { type: 'string', short: 'n', default: '20' }
+    }
+  },
+
   // Container access
   terminal: {
     description: 'Open a terminal session in the running container',
     options: {
-      env: { type: 'string', short: 'e', default: 'production' }
+      env: { type: 'string', short: 'e', default: 'production' },
+      app: { type: 'string', short: 'a' }
     }
   },
   run: {
     description: 'Run a command in the container',
     args: '<command...>',
     options: {
-      env: { type: 'string', short: 'e', default: 'production' }
+      env: { type: 'string', short: 'e', default: 'production' },
+      app: { type: 'string', short: 'a' }
     }
   }
 }
@@ -182,11 +216,13 @@ function showHelp() {
     'Authentication': ['login', 'logout', 'whoami'],
     'Project': ['projects', 'project:update', 'init', 'link'],
     'Environments': ['environments', 'environment:create', 'environment:update'],
-    'Deployment': ['slide', 'deployments', 'logs'],
+    'Deployment': ['push', 'slide', 'deployments', 'logs'],
     'Database': ['db:create', 'db:url'],
     'Services': ['services'],
+    'Backups': ['backup:create', 'backup:list', 'backup:restore'],
     'Env Variables': ['env', 'env:set', 'env:unset'],
-    'Container': ['terminal', 'run']
+    'Container': ['terminal', 'run'],
+    'Admin': ['audit-log']
   }
 
   for (const [groupName, cmds] of Object.entries(groups)) {

package/src/lib/api.js

@@ -33,7 +33,17 @@ async function apiRequest(method, path, options = {}) {
 
   try {
     const response = await fetch(url, fetchOptions)
-    const body = await response.json()
+    const text = await response.text()
+
+    let body
+    try {
+      body = JSON.parse(text)
+    } catch {
+      if (!response.ok) {
+        throw new APIError(text || `Request failed with status ${response.status}`, response.status)
+      }
+      throw new APIError(`Unexpected response from server: ${text}`, response.status)
+    }
 
     if (!response.ok) {
       const message = body.message || body.error || `Request failed with status ${response.status}`
@@ -73,7 +83,17 @@ async function apiUpload(path, fieldName, buffer, filename) {
       body: formData
     })
 
-    const body = await response.json()
+    const text = await response.text()
+
+    let body
+    try {
+      body = JSON.parse(text)
+    } catch {
+      if (!response.ok) {
+        throw new APIError(text || `Upload failed with status ${response.status}`, response.status)
+      }
+      throw new APIError(`Unexpected response from server: ${text}`, response.status)
+    }
 
     if (!response.ok) {
       const message = body.message || body.error || `Upload failed with status ${response.status}`
@@ -134,3 +154,15 @@ api.services = {
   get: (id) => api.get(`/services/${id}`),
   delete: (id) => api.delete(`/services/${id}`)
 }
+
+// Backup endpoints
+api.backups = {
+  create: (serviceId) => api.post(`/services/${serviceId}/backups`),
+  list: (serviceId) => api.get(`/services/${serviceId}/backups`),
+  restore: (backupId) => api.post(`/backups/${backupId}/restore`)
+}
+
+// Audit log endpoints
+api.auditLogs = {
+  list: (page = 1, limit = 20) => api.get(`/audit-logs?page=${page}&limit=${limit}`)
+}

package/src/lib/utils.js

@@ -32,6 +32,15 @@ export function formatDate(timestamp) {
   return date.toLocaleString()
 }
 
+export function formatBytes(bytes) {
+  if (!bytes) return 'N/A'
+  const units = ['B', 'KB', 'MB', 'GB']
+  let i = 0
+  let size = bytes
+  while (size >= 1024 && i < units.length - 1) { size /= 1024; i++ }
+  return `${size.toFixed(i === 0 ? 0 : 1)} ${units[i]}`
+}
+
 export function formatDuration(seconds) {
   if (!seconds) return 'N/A'
   if (seconds < 60) return `${seconds}s`
@@ -59,22 +68,27 @@ export function createSpinner(text) {
   const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
   let i = 0
   let interval = null
+  let currentText = text
 
   return {
     start() {
-      process.stdout.write(`\r${c.info(frames[0])} ${text}`)
+      process.stdout.write(`\r${c.info(frames[0])} ${currentText}`)
       interval = setInterval(() => {
         i = (i + 1) % frames.length
-        process.stdout.write(`\r${c.info(frames[i])} ${text}`)
+        process.stdout.write(`\x1b[2K\r${c.info(frames[i])} ${currentText}`)
       }, 80)
       return this
     },
+    setText(newText) {
+      currentText = newText
+      return this
+    },
     stop(finalText) {
       if (interval) {
         clearInterval(interval)
         interval = null
       }
-      process.stdout.write('\r' + ' '.repeat(text.length + 4) + '\r')
+      process.stdout.write(`\x1b[2K\r`)
       if (finalText) console.log(finalText)
       return this
     },