sloss-cli 1.0.0

package/README.md

@@ -0,0 +1,60 @@
+# sloss-cli
+
+Command-line interface for [Sloss](https://github.com/aualdrich/sloss) — a self-hosted IPA/APK distribution server inspired by Diawi.
+
+## Install
+
+```bash
+npm install -g sloss-cli
+```
+
+## Quick Start
+
+```bash
+# Authenticate (saves API key to ~/.config/sloss/credentials.json)
+sloss login
+
+# List recent builds
+sloss list
+
+# Upload an IPA
+sloss upload path/to/App.ipa --platform ios --profile preview
+
+# Upload an APK
+sloss upload path/to/app.apk --platform android --profile development
+
+# Get build details
+sloss info <build-id>
+
+# Delete a build
+sloss delete <build-id>
+```
+
+## Authentication
+
+API key resolution order (highest → lowest priority):
+1. `--api-key` CLI flag
+2. `SLOSS_API_KEY` environment variable
+3. `~/.config/sloss/credentials.json` (saved by `sloss login`)
+
+## Server URL
+
+URL resolution order:
+1. `--url` CLI flag
+2. `SLOSS_URL` environment variable
+3. `~/.config/sloss/credentials.json`
+4. Default: `https://sloss.ngrok.app`
+
+## Global Options
+
+```
+--api-key <key>   Override API key
+--url <url>       Override server URL
+--json            Output as JSON
+--version         Show version
+--help            Show help
+```
+
+## License
+
+MIT

package/bin/sloss.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+/**
+ * Sloss CLI - Command-line interface for Sloss IPA/APK build server
+ */
+
+import { Command } from 'commander';
+import { resolveConfig, resolveUrl } from '../src/config.js';
+import { loginCommand } from '../src/commands/login.js';
+import { listCommand } from '../src/commands/list.js';
+import { uploadCommand } from '../src/commands/upload.js';
+import { infoCommand } from '../src/commands/info.js';
+import { deleteCommand } from '../src/commands/delete.js';
+
+const program = new Command();
+
+program
+  .name('sloss')
+  .description('CLI for Sloss IPA/APK build server')
+  .version('1.0.0')
+  .option('--api-key <key>', 'API key (overrides SLOSS_API_KEY env var)')
+  .option('--url <url>', 'Server URL (overrides SLOSS_URL env var)')
+  .option('--json', 'Output as JSON instead of human-readable format');
+
+// Login command
+program
+  .command('login')
+  .description('Authenticate and save your API key to sloss.json')
+  .option('--email <email>', 'Email address')
+  .option('--password <password>', 'Password (prefer interactive prompt)')
+  .action(async (options) => {
+    try {
+      const baseUrl = resolveUrl(program.opts());
+      await loginCommand(options, baseUrl);
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+// List command
+program
+  .command('list')
+  .description('List recent builds')
+  .option('--limit <number>', 'Maximum number of builds to list', '10')
+  .action(async (options) => {
+    try {
+      const config = resolveConfig(program.opts());
+      await listCommand(options, config);
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+// Upload command
+program
+  .command('upload <file>')
+  .description('Upload an IPA or APK file')
+  .requiredOption('--platform <platform>', 'Platform (ios or android)')
+  .option('--app-name <name>', 'App name')
+  .option('--version <version>', 'Version number')
+  .option('--build-number <number>', 'Build number')
+  .option('--profile <profile>', 'Build profile (development, preview, production)')
+  .action(async (file, options) => {
+    try {
+      const config = resolveConfig(program.opts());
+      await uploadCommand(file, options, config);
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+// Info command
+program
+  .command('info <build-id>')
+  .description('Get details about a specific build')
+  .action(async (buildId) => {
+    try {
+      const config = resolveConfig(program.opts());
+      await infoCommand(buildId, config);
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+// Delete command
+program
+  .command('delete <build-id>')
+  .description('Delete a build')
+  .action(async (buildId) => {
+    try {
+      const config = resolveConfig(program.opts());
+      await deleteCommand(buildId, config);
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "sloss-cli",
+  "version": "1.0.0",
+  "description": "CLI for Sloss — a self-hosted IPA/APK distribution server",
+  "type": "module",
+  "bin": {
+    "sloss": "./bin/sloss.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "keywords": ["sloss", "ios", "android", "ipa", "apk", "build", "distribution", "testflight", "diawi"],
+  "author": "Front Porch Software",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aualdrich/sloss-cli.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "commander": "^12.0.0"
+  }
+}

package/src/client.js

@@ -0,0 +1,91 @@
+/**
+ * HTTP client for Sloss API
+ * Uses native fetch (Node 18+)
+ */
+
+export class SlossClient {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+
+  async request(method, path, body = null) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      'Authorization': `Bearer ${this.apiKey}`,
+    };
+
+    const options = { method, headers };
+
+    if (body && !(body instanceof FormData)) {
+      headers['Content-Type'] = 'application/json';
+      options.body = JSON.stringify(body);
+    } else if (body instanceof FormData) {
+      options.body = body;
+      // Don't set Content-Type for FormData - fetch will set it with boundary
+    }
+
+    const response = await fetch(url, options);
+
+    if (!response.ok) {
+      let errorMsg = `HTTP ${response.status} ${response.statusText}`;
+      try {
+        const errorBody = await response.json();
+        if (errorBody.error) {
+          errorMsg = errorBody.error;
+          if (errorBody.detail) errorMsg += `: ${errorBody.detail}`;
+        }
+      } catch {
+        // If JSON parsing fails, use the generic message
+      }
+      throw new Error(errorMsg);
+    }
+
+    // Handle 204 No Content
+    if (response.status === 204) {
+      return null;
+    }
+
+    return await response.json();
+  }
+
+  async listUploads(limit = 10) {
+    return await this.request('GET', `/api/uploads?limit=${limit}`);
+  }
+
+  async getUpload(id) {
+    return await this.request('GET', `/api/uploads/${id}`);
+  }
+
+  async deleteUpload(id) {
+    return await this.request('DELETE', `/api/uploads/${id}`);
+  }
+
+  async uploadFile(filePath, platform, metadata = {}) {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    
+    // Read file as buffer
+    const fileBuffer = await fs.readFile(filePath);
+    const fileName = path.basename(filePath);
+
+    // Create FormData
+    const formData = new FormData();
+    
+    // Determine field name based on platform
+    const fieldName = platform === 'android' ? 'apk' : 'ipa';
+    const blob = new Blob([fileBuffer]);
+    formData.append(fieldName, blob, fileName);
+
+    // Add platform
+    formData.append('platform', platform);
+
+    // Add optional metadata fields
+    if (metadata.appName) formData.append('app_name', metadata.appName);
+    if (metadata.version) formData.append('version', metadata.version);
+    if (metadata.buildNumber) formData.append('build_number', metadata.buildNumber);
+    if (metadata.profile) formData.append('profile', metadata.profile);
+
+    return await this.request('POST', '/upload', formData);
+  }
+}

package/src/commands/delete.js

@@ -0,0 +1,17 @@
+/**
+ * Delete command - Delete a build
+ */
+
+import { SlossClient } from '../client.js';
+import { formatDelete } from '../format.js';
+
+export async function deleteCommand(buildId, config) {
+  if (!buildId) {
+    throw new Error('Build ID is required');
+  }
+
+  const client = new SlossClient(config.baseUrl, config.apiKey);
+  await client.deleteUpload(buildId);
+  
+  console.log(formatDelete(config.jsonMode));
+}

package/src/commands/info.js

@@ -0,0 +1,17 @@
+/**
+ * Info command - Get details about a specific build
+ */
+
+import { SlossClient } from '../client.js';
+import { formatInfo } from '../format.js';
+
+export async function infoCommand(buildId, config) {
+  if (!buildId) {
+    throw new Error('Build ID is required');
+  }
+
+  const client = new SlossClient(config.baseUrl, config.apiKey);
+  const upload = await client.getUpload(buildId);
+  
+  console.log(formatInfo(upload, config.jsonMode));
+}

package/src/commands/list.js

@@ -0,0 +1,15 @@
+/**
+ * List command - List recent builds
+ */
+
+import { SlossClient } from '../client.js';
+import { formatList } from '../format.js';
+
+export async function listCommand(options, config) {
+  const limit = parseInt(options.limit, 10) || 10;
+  
+  const client = new SlossClient(config.baseUrl, config.apiKey);
+  const uploads = await client.listUploads(limit);
+  
+  console.log(formatList(uploads, config.jsonMode));
+}

package/src/commands/login.js

@@ -0,0 +1,143 @@
+/**
+ * Login command - Authenticate with Sloss and store API key locally
+ *
+ * Flow:
+ *   1. Prompt for email + password (password hidden)
+ *   2. POST /auth/login → Cognito JWT
+ *   3. GET /api-keys (with JWT) → user's API key UUID
+ *   4. Write API key to sloss.json in cwd
+ */
+
+import { createInterface } from 'readline';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const CREDENTIALS_PATH = join(homedir(), '.config', 'sloss', 'credentials.json');
+
+/**
+ * Prompt for a value, optionally hiding input (for passwords)
+ */
+function prompt(question, hidden = false) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    if (hidden) {
+      // Suppress echoed characters for password input
+      process.stdout.write(question);
+
+      let value = '';
+
+      const onData = (char) => {
+        char = char.toString();
+        if (char === '\n' || char === '\r' || char === '\u0004') {
+          // Enter pressed
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener('data', onData);
+          process.stdout.write('\n');
+          rl.close();
+          resolve(value);
+        } else if (char === '\u0003') {
+          // Ctrl+C
+          process.stdout.write('\n');
+          process.exit(0);
+        } else if (char === '\u007f' || char === '\b') {
+          // Backspace
+          if (value.length > 0) {
+            value = value.slice(0, -1);
+          }
+        } else {
+          value += char;
+        }
+      };
+
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.setEncoding('utf8');
+      process.stdin.on('data', onData);
+    } else {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    }
+  });
+}
+
+export async function loginCommand(options, baseUrl) {
+  const email    = options.email    || await prompt('Email: ');
+  const password = options.password || await prompt('Password: ', true);
+
+  // Step 1: Authenticate → get Cognito JWT
+  process.stdout.write('Authenticating...');
+
+  let jwt;
+  try {
+    const loginRes = await fetch(`${baseUrl}/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, password }),
+    });
+
+    const loginBody = await loginRes.json();
+
+    if (!loginRes.ok || !loginBody.success) {
+      process.stdout.write(' ✗\n');
+      throw new Error(loginBody.error || `Login failed (HTTP ${loginRes.status})`);
+    }
+
+    jwt = loginBody.token;
+    process.stdout.write(' ✓\n');
+  } catch (err) {
+    if (err.message.includes('fetch')) {
+      throw new Error(`Cannot reach Sloss server at ${baseUrl}`);
+    }
+    throw err;
+  }
+
+  // Step 2: Fetch the user's API key using the JWT
+  process.stdout.write('Fetching API key...');
+
+  let apiKey;
+  const keysRes = await fetch(`${baseUrl}/api-keys`, {
+    headers: { Authorization: `Bearer ${jwt}` },
+  });
+
+  const keysBody = await keysRes.json();
+
+  if (!keysRes.ok) {
+    process.stdout.write(' ✗\n');
+    throw new Error(keysBody.error || `Failed to fetch API key (HTTP ${keysRes.status})`);
+  }
+
+  apiKey = keysBody.apiKey?.id;
+
+  // If user has no API key yet, generate one
+  if (!apiKey) {
+    const genRes = await fetch(`${baseUrl}/api-keys/generate`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${jwt}` },
+    });
+    const genBody = await genRes.json();
+    if (!genRes.ok || !genBody.success) {
+      process.stdout.write(' ✗\n');
+      throw new Error(genBody.error || 'Failed to generate API key');
+    }
+    apiKey = genBody.apiKey.id;
+  }
+
+  process.stdout.write(' ✓\n');
+
+  // Step 3: Write credentials to ~/.config/sloss/credentials.json
+  const config = { apiKey, url: baseUrl, email };
+  mkdirSync(join(homedir(), '.config', 'sloss'), { recursive: true });
+  writeFileSync(CREDENTIALS_PATH, JSON.stringify(config, null, 2) + '\n', 'utf8');
+
+  console.log(`\n✅ Logged in as ${email}`);
+  console.log(`   API key saved to ${CREDENTIALS_PATH}`);
+  console.log(`\n   Add to your shell (optional):\n   export SLOSS_API_KEY="${apiKey}"`);
+}

package/src/commands/upload.js

@@ -0,0 +1,33 @@
+/**
+ * Upload command - Upload an IPA or APK
+ */
+
+import { SlossClient } from '../client.js';
+import { formatUpload } from '../format.js';
+
+export async function uploadCommand(filePath, options, config) {
+  if (!filePath) {
+    throw new Error('File path is required');
+  }
+
+  if (!options.platform) {
+    throw new Error('Platform is required (--platform ios or --platform android)');
+  }
+
+  const platform = options.platform.toLowerCase();
+  if (!['ios', 'android'].includes(platform)) {
+    throw new Error('Platform must be either "ios" or "android"');
+  }
+
+  const metadata = {
+    appName: options.appName,
+    version: options.version,
+    buildNumber: options.buildNumber,
+    profile: options.profile,
+  };
+
+  const client = new SlossClient(config.baseUrl, config.apiKey);
+  const result = await client.uploadFile(filePath, platform, metadata);
+  
+  console.log(formatUpload(result, config.jsonMode));
+}

package/src/config.js

@@ -0,0 +1,68 @@
+/**
+ * Configuration resolver for Sloss CLI
+ *
+ * API key resolution order (highest → lowest priority):
+ *   1. --api-key CLI flag
+ *   2. SLOSS_API_KEY environment variable
+ *   3. apiKey field in ~/.config/sloss/credentials.json
+ *
+ * URL resolution order:
+ *   1. --url CLI flag
+ *   2. SLOSS_URL environment variable
+ *   3. url field in ~/.config/sloss/credentials.json
+ *   4. Default production URL
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const CREDENTIALS_PATH = join(homedir(), '.config', 'sloss', 'credentials.json');
+const DEFAULT_URL = 'https://sloss.ngrok.app';
+
+/**
+ * Load and parse ~/.config/sloss/credentials.json, returning {} if not found / invalid.
+ */
+function loadCredentials() {
+  try {
+    const raw = readFileSync(CREDENTIALS_PATH, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export function resolveConfig(options = {}) {
+  const file = loadCredentials();
+
+  // API Key: flag > env > sloss.json > error
+  const apiKey = options.apiKey || process.env.SLOSS_API_KEY || file.apiKey;
+  if (!apiKey) {
+    throw new Error(
+      'No API key found.\n' +
+      '  Run `sloss login` to authenticate, or\n' +
+      '  set SLOSS_API_KEY env var, or\n' +
+      '  pass --api-key <key>'
+    );
+  }
+
+  // URL: flag > env > sloss.json > default
+  const rawUrl = options.url || process.env.SLOSS_URL || file.url || DEFAULT_URL;
+  const baseUrl = rawUrl.replace(/\/$/, '');
+
+  return {
+    apiKey,
+    baseUrl,
+    jsonMode: options.json || false,
+  };
+}
+
+/**
+ * Resolve just the base URL (no API key required).
+ * Used by commands like `login` that don't have a key yet.
+ */
+export function resolveUrl(options = {}) {
+  const file = loadCredentials();
+  const rawUrl = options.url || process.env.SLOSS_URL || file.url || DEFAULT_URL;
+  return rawUrl.replace(/\/$/, '');
+}

package/src/format.js

@@ -0,0 +1,101 @@
+/**
+ * Output formatters for Sloss CLI
+ * Handles both human-readable table output and JSON mode
+ */
+
+export function formatList(uploads, jsonMode = false) {
+  if (jsonMode) {
+    return JSON.stringify(uploads, null, 2);
+  }
+
+  if (uploads.length === 0) {
+    return 'No builds found.';
+  }
+
+  // Calculate column widths
+  const rows = uploads.map(u => ({
+    id: (u.id || '').substring(0, 8),
+    platform: u.platform || '—',
+    app: u.app_name || '—',
+    version: u.version || '—',
+    build: u.build_number || '—',
+    profile: u.profile || '—',
+    uploaded: formatDate(u.uploaded_at || u.created_at),
+  }));
+
+  // Build table
+  const header = 'ID       PLATFORM APP           VERSION    BUILD  PROFILE      UPLOADED';
+  const separator = '─'.repeat(header.length);
+
+  const lines = [header, separator];
+
+  for (const row of rows) {
+    const line = [
+      row.id.padEnd(8),
+      row.platform.padEnd(8),
+      row.app.substring(0, 13).padEnd(13),
+      row.version.substring(0, 10).padEnd(10),
+      row.build.substring(0, 6).padEnd(6),
+      row.profile.substring(0, 12).padEnd(12),
+      row.uploaded,
+    ].join(' ');
+    lines.push(line);
+  }
+
+  return lines.join('\n');
+}
+
+export function formatInfo(upload, jsonMode = false) {
+  if (jsonMode) {
+    return JSON.stringify(upload, null, 2);
+  }
+
+  const lines = [
+    `ID:           ${upload.id}`,
+    `Platform:     ${upload.platform || '—'}`,
+    `App Name:     ${upload.app_name || '—'}`,
+    `Bundle ID:    ${upload.bundle_id || '—'}`,
+    `Version:      ${upload.version || '—'}`,
+    `Build Number: ${upload.build_number || '—'}`,
+    `Profile:      ${upload.profile || '—'}`,
+    `Uploaded:     ${formatDate(upload.uploaded_at || upload.created_at)}`,
+    `Page URL:     ${upload.pageUrl || '—'}`,
+    `Download URL: ${upload.downloadUrl || '—'}`,
+  ];
+
+  return lines.join('\n');
+}
+
+export function formatUpload(result, jsonMode = false) {
+  if (jsonMode) {
+    return JSON.stringify(result, null, 2);
+  }
+
+  const lines = [
+    '✅ Upload successful!',
+    '',
+    `Build ID:     ${result.id}`,
+    `Page URL:     ${result.page_url}`,
+    `Install URL:  ${result.install_url}`,
+  ];
+
+  return lines.join('\n');
+}
+
+export function formatDelete(jsonMode = false) {
+  if (jsonMode) {
+    return JSON.stringify({ ok: true }, null, 2);
+  }
+
+  return '✅ Build deleted successfully';
+}
+
+function formatDate(dateStr) {
+  if (!dateStr) return '—';
+  try {
+    const date = new Date(dateStr);
+    return date.toLocaleDateString() + ' ' + date.toLocaleTimeString();
+  } catch {
+    return '—';
+  }
+}