sloss-cli 1.1.0 → 1.2.1

package/README.md

@@ -1,6 +1,6 @@
 # sloss-cli
 
-Command-line interface for [Sloss](https://github.com/aualdrich/sloss) — a self-hosted IPA/APK distribution server inspired by Diawi.
+Command-line interface for [Sloss](https://github.com/aualdrich/sloss) — a self-hosted build distribution server for Expo apps. Supports iOS and Android.
 
 ## Install
 
@@ -11,43 +11,167 @@ npm install -g sloss-cli
 Or as a project dependency:
 
 ```bash
-npm install sloss-cli
+npm install --save-dev sloss-cli
 # or
-bun add sloss-cli
+bun add --dev sloss-cli
 ```
 
-## Quick Start
+## Setup
+
+### 1. Create a Sloss account
+
+Sign up at your team's Sloss instance (e.g. `https://sloss.example.com/signup`). After signing up, you'll receive an API key on the onboarding page. You can also find it under **Settings → API Key**.
+
+### 2. Authenticate the CLI
 
 ```bash
-# Authenticate (saves API key to ~/.config/sloss/credentials.json)
 sloss login
+```
+
+This prompts for your email and password, fetches your API key, and saves it to `~/.config/sloss/credentials.json`. You only need to do this once per machine.
+
+Alternatively, set the `SLOSS_API_KEY` environment variable or pass `--api-key` to any command.
+
+### 3. Add `.sloss.json` to your Expo project
+
+Create a `.sloss.json` file in your Expo project root (next to `app.json`):
+
+```json
+{
+  "type": "expo",
+  "app_name": "MyApp",
+  "bundle_id": "com.mycompany.myapp",
+  "version_file": "app.version.json",
+  "profiles": {
+    "development": {
+      "bundle_id_suffix": ".dev"
+    },
+    "preview": {
+      "bundle_id_suffix": ".preview"
+    },
+    "production": {
+      "bundle_id_suffix": ""
+    }
+  }
+}
+```
+
+| Field | Description |
+|-------|-------------|
+| `type` | Always `"expo"` |
+| `app_name` | Display name for the build on Sloss |
+| `bundle_id` | Base bundle identifier |
+| `version_file` | Path to a JSON file containing `version` and `buildNumber` (relative to project root) |
+| `profiles` | Build profile config — `bundle_id_suffix` is appended to `bundle_id` per profile |
+
+### 4. Create `app.version.json`
+
+Sloss reads version info from a dedicated file so the build agent can bump versions independently:
+
+```json
+{
+  "version": "1.0.0",
+  "buildNumber": "1"
+}
+```
+
+Reference this in your `app.json` / `app.config.js` so Expo picks it up:
+
+```js
+// app.config.js
+const version = require('./app.version.json');
+
+module.exports = {
+  expo: {
+    version: version.version,
+    ios: { buildNumber: String(version.buildNumber) },
+    android: { versionCode: parseInt(version.buildNumber, 10) },
+    // ... rest of your config
+  },
+};
+```
+
+## Usage
+
+### Queue a build
+
+From your Expo project directory:
+
+```bash
+# iOS development build (default)
+sloss build
+
+# Android preview build
+sloss build --platform android --profile preview
+
+# Production build with minor version bump
+sloss build --profile production --bump minor
+```
+
+The CLI packages your project via `git archive`, uploads it to Sloss, and a build agent picks it up. You'll get a link to the build page with live logs.
+
+#### Build options
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--platform <platform>` | `ios` | `ios` or `android` |
+| `--profile <profile>` | `development` | `development`, `preview`, or `production` |
+| `--bump <type>` | `patch` | Version bump for production builds: `patch`, `minor`, or `major` |
+| `--dir <path>` | `.` | Project directory (if not running from project root) |
 
-# List recent builds
+### List builds
+
+```bash
 sloss list
+sloss list --limit 20
+```
+
+### Get build details
 
+```bash
+sloss info <build-id>
+```
+
+### Upload a pre-built artifact
+
+If you already have an IPA or APK (e.g. from a local build):
+
+```bash
 # Upload an IPA
-sloss upload path/to/App.ipa --platform ios --profile preview
+sloss upload ./build/MyApp.ipa --platform ios --profile preview
 
 # Upload an APK
-sloss upload path/to/app.apk --platform android --profile development
+sloss upload ./build/app-release.apk --platform android --profile production
+```
 
-# Get build details
-sloss info <build-id>
+#### Upload options
 
-# Delete a build
+| Flag | Description |
+|------|-------------|
+| `--platform <platform>` | **Required.** `ios` or `android` |
+| `--profile <profile>` | Build profile: `development`, `preview`, or `production` |
+| `--app-name <name>` | App display name |
+| `--version <version>` | Version string |
+| `--build-number <number>` | Build number |
+
+### Delete a build
+
+```bash
 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:
+URL resolution order (highest → lowest priority):
+
 1. `--url` CLI flag
 2. `SLOSS_URL` environment variable
 3. `~/.config/sloss/credentials.json`
@@ -55,40 +179,53 @@ URL resolution order:
 
 ## Global Options
 
-```
---api-key <key>   Override API key
---url <url>       Override server URL
---json            Output as JSON
---version         Show version
---help            Show help
+| Flag | Description |
+|------|-------------|
+| `--api-key <key>` | Override API key |
+| `--url <url>` | Override server URL |
+| `--json` | Output as JSON |
+| `--version` | Show CLI version |
+| `--help` | Show help |
+
+## How It Works
+
+1. `sloss build` reads `.sloss.json` from your project root
+2. Your committed source is packaged into a tarball via `git archive`
+3. The tarball is uploaded to your Sloss server
+4. A build agent picks up the job and builds it locally using Xcode (iOS) or Gradle (Android)
+5. The finished IPA/APK is uploaded back to Sloss
+6. You get a build page with install links and QR codes for on-device installation
+
+## OpenClaw Skill
+
+This package includes an [OpenClaw](https://openclaw.ai) skill so your AI agent can use the Sloss CLI. After installing `sloss-cli`, add the skill directory to your OpenClaw config:
+
+```json5
+// ~/.openclaw/openclaw.json
+{
+  skills: {
+    load: {
+      extraDirs: ["./node_modules/sloss-cli/skills"]
+    }
+  }
+}
 ```
 
-## Publishing to npm
-
-Prerequisites:
-- An [npm](https://www.npmjs.com) account with publish access
-- An npm access token (Granular token with "Bypass 2FA" enabled, or an Automation classic token)
+Or copy the skill into your workspace:
 
 ```bash
-# Set your npm token
-echo "//registry.npmjs.org/:_authToken=YOUR_TOKEN" > ~/.npmrc
-
-# Bump version (patch/minor/major)
-npm version patch
-
-# Publish
-npm publish --access public
+cp -r ./node_modules/sloss-cli/skills/sloss <workspace>/skills/sloss
 ```
 
-The package is published as [`sloss-cli`](https://www.npmjs.com/package/sloss-cli) under the `front-porch-software` npm account.
+The skill is also available on [ClawHub](https://clawhub.com):
 
-### What gets published
-
-Only `bin/`, `src/`, and `README.md` are included in the npm package (controlled by `files` in `package.json`). Build scripts and other development files are excluded.
+```bash
+clawhub install sloss
+```
 
 ## Related
 
-- **[Sloss Server](https://github.com/aualdrich/sloss)** — The distribution server that this CLI talks to
+- **[Sloss Server](https://github.com/aualdrich/sloss)** — The self-hosted distribution server
 
 ## License
 

package/bin/sloss.js

@@ -12,6 +12,7 @@ import { uploadCommand } from '../src/commands/upload.js';
 import { infoCommand } from '../src/commands/info.js';
 import { deleteCommand } from '../src/commands/delete.js';
 import { buildCommand } from '../src/commands/build.js';
+import { initCommand } from '../src/commands/init.js';
 
 const program = new Command();
 
@@ -23,6 +24,21 @@ program
   .option('--url <url>', 'Server URL (overrides SLOSS_URL env var)')
   .option('--json', 'Output as JSON instead of human-readable format');
 
+// Init command
+program
+  .command('init')
+  .description('Set up a project for Sloss builds')
+  .option('--dir <path>', 'Project directory (default: current directory)')
+  .option('--url <url>', 'Server URL')
+  .action(async (options) => {
+    try {
+      await initCommand({ ...options, url: program.opts().url || options.url });
+    } catch (error) {
+      console.error(`Error: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
 // Login command
 program
   .command('login')

package/package.json

@@ -1,22 +1,33 @@
 {
   "name": "sloss-cli",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "CLI for Sloss — a self-hosted IPA/APK distribution server",
   "type": "module",
   "bin": {
-    "sloss": "./bin/sloss.js"
+    "sloss": "bin/sloss.js"
   },
   "files": [
     "bin/",
     "src/",
+    "skills/",
     "README.md"
   ],
-  "keywords": ["sloss", "ios", "android", "ipa", "apk", "build", "distribution", "testflight", "diawi"],
+  "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"
+    "url": "git+https://github.com/aualdrich/sloss-cli.git"
   },
   "engines": {
     "node": ">=18.0.0"

package/skills/sloss/SKILL.md

@@ -0,0 +1,136 @@
+---
+name: sloss
+description: Manage Sloss — the local IPA/APK distribution server for Switchboard. Use when Austin asks to check Sloss status, restart it, view builds, get an install link, or upload an IPA manually.
+---
+
+# Sloss — IPA/APK Distribution Server
+
+Sloss is a lightweight self-hosted build distribution server, inspired by Diawi. Named after [Sloss Furnaces](https://www.slossfurnaces.com/) in Birmingham, AL.
+
+## Repos
+
+| Repo | Purpose | Local path |
+|------|---------|------------|
+| [aualdrich/sloss](https://github.com/aualdrich/sloss) | Build server (Node.js/Express) | `~/sloss/` |
+| [aualdrich/sloss-cli](https://github.com/aualdrich/sloss-cli) | CLI (`sloss` command) | `~/sloss/cli/` |
+
+> **Note:** `cli/` is a separate repo cloned inside `~/sloss/` for convenience. It is **not** tracked by the sloss server repo (gitignored). Always commit/push CLI changes from `~/sloss/cli/`.
+
+## Server Setup
+
+- **Port:** `3001`
+- **Public URL:** `https://sloss.ngrok.app` (via ngrok LaunchAgent)
+- **LaunchAgent:** `com.switchboard.sloss` — auto-starts at login, KeepAlive
+- **Log:** `/tmp/sloss.log`
+- **Auth:** Cognito JWT (web UI) + per-user API keys (CLI/API)
+
+## Server Status & Restart
+
+```bash
+# Check if running
+curl -s http://localhost:3001/ | head -3
+
+# View logs
+tail -f /tmp/sloss.log
+
+# Restart
+launchctl unload ~/Library/LaunchAgents/com.switchboard.sloss.plist
+launchctl load ~/Library/LaunchAgents/com.switchboard.sloss.plist
+```
+
+## CLI Usage
+
+The `sloss` CLI lives in `~/sloss/cli/`. To use it from anywhere, run `node ~/sloss/cli/bin/sloss.js` or install it globally.
+
+### Authentication
+
+```bash
+# Login once — saves API key to ~/.config/sloss/credentials.json
+sloss login
+# → prompts for email + password, fetches API key, saves credentials
+```
+
+API key resolution order (highest → lowest priority):
+1. `--api-key` flag
+2. `SLOSS_API_KEY` env var
+3. `~/.config/sloss/credentials.json`
+
+### Commands
+
+```bash
+sloss login                          # Authenticate + save credentials
+sloss build [options]                # Queue a build via the Sloss build agent
+sloss list [--limit 20]              # List recent builds
+sloss info <build-id>                # Details for a specific build
+sloss upload <file> --platform ios   # Upload an IPA or APK manually
+sloss delete <build-id>              # Delete a build
+
+# Build options
+sloss build --profile development    # Build profile (development|preview|production)
+sloss build --platform ios           # Platform (ios|android), default: ios
+sloss build --bump minor             # Version bump type (patch|minor|major), default: patch
+sloss build --dir /path/to/project   # Project directory, default: current dir
+
+# Global flags (all commands)
+sloss --url <url> <command>          # Override server URL
+sloss --api-key <key> <command>      # Override API key
+sloss --json <command>               # JSON output
+```
+
+### Build Flow
+
+1. CLI reads `.sloss.json` from the project root
+2. Tars up committed source via `git archive` (respects `.gitignore`)
+3. Uploads tarball to `POST /api/builds/start` with your per-user API key
+4. Build agent (mac-mini) picks up the job, extracts, builds locally via Xcode
+5. Agent uploads the IPA/APK artifact to Sloss when done
+6. Build page with live logs at `https://sloss.ngrok.app/builds/<id>`
+
+## Manual Upload via curl
+
+```bash
+curl -s -X POST https://sloss.ngrok.app/upload \
+  -H "Authorization: Bearer <your-api-key>" \
+  -F "ipa=@/path/to/App.ipa" \
+  -F "app_name=Switchboard" \
+  -F "bundle_id=com.aualdrich1.switchboard.preview" \
+  -F "version=1.0.0" \
+  -F "build_number=36" \
+  -F "profile=preview"
+```
+
+**profile** values: `development` · `preview` · `production`
+
+## Install on Device
+
+After a build, Sloss outputs:
+```
+🏭 Sloss build page : https://sloss.ngrok.app/b/<uuid>
+📲 Install URL      : itms-services://...
+```
+
+To install on iPhone:
+1. Open the `itms-services://...` URL in **Safari** (not Chrome), or
+2. Open the build page URL in Safari and tap **Install**
+
+## API Endpoints
+
+| Method | Path                  | Auth | Description                  |
+|--------|-----------------------|------|------------------------------|
+| POST   | `/upload`             | Yes  | Upload an IPA or APK         |
+| GET    | `/b/:id`              | No   | Build landing page           |
+| GET    | `/m/:id`              | No   | Apple OTA manifest plist     |
+| GET    | `/ipa/:id`            | No   | Raw IPA download             |
+| GET    | `/`                   | No   | All builds, newest first     |
+| POST   | `/auth/login`         | No   | Login → Cognito JWT          |
+| GET    | `/api-keys`           | JWT  | Get current user's API key   |
+| POST   | `/api-keys/generate`  | JWT  | Generate new API key         |
+| POST   | `/api-keys/regenerate`| JWT  | Replace existing API key     |
+
+## Build Agent
+
+The Sloss build agent runs as a LaunchAgent (`com.switchboard.sloss-agent`) on the Mac Mini, polling for queued jobs every 10s. It extracts the tarball, runs `eas build --local`, and uploads the resulting IPA/APK back to Sloss.
+
+- **LaunchAgent:** `com.switchboard.sloss-agent`
+- **Log:** `/Users/administrator/Library/Logs/sloss-agent.log`
+- **Agent code:** `~/sloss/agent/`

package/src/commands/init.js

@@ -0,0 +1,290 @@
+/**
+ * Init command - Set up a project for Sloss builds
+ *
+ * Flow:
+ *   1. Check if user is logged in, prompt login if not
+ *   2. Detect project type (Expo, React Native, etc.)
+ *   3. Auto-detect app name and bundle ID from project config
+ *   4. Prompt user to confirm / override detected values
+ *   5. Generate .sloss.json with conventional defaults
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { createInterface } from 'readline';
+import { loginCommand } from './login.js';
+
+const CREDENTIALS_PATH = join(homedir(), '.config', 'sloss', 'credentials.json');
+
+function prompt(question, defaultValue = '') {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    const suffix = defaultValue ? ` (${defaultValue})` : '';
+    rl.question(`${question}${suffix}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+function promptYesNo(question, defaultYes = true) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    const hint = defaultYes ? 'Y/n' : 'y/N';
+    rl.question(`${question} (${hint}): `, (answer) => {
+      rl.close();
+      const val = answer.trim().toLowerCase();
+      if (val === '') resolve(defaultYes);
+      else resolve(val === 'y' || val === 'yes');
+    });
+  });
+}
+
+/**
+ * Detect project type and extract app metadata from config files.
+ */
+function detectProject(projectDir) {
+  const detected = {
+    type: null,
+    appName: null,
+    bundleId: null,
+  };
+
+  // Try Expo: app.json
+  const appJsonPath = join(projectDir, 'app.json');
+  if (existsSync(appJsonPath)) {
+    try {
+      const appJson = JSON.parse(readFileSync(appJsonPath, 'utf8'));
+      const expo = appJson.expo || appJson;
+      detected.type = 'expo';
+      detected.appName = expo.name || null;
+      detected.bundleId = expo.ios?.bundleIdentifier || expo.android?.package || null;
+    } catch { /* ignore parse errors */ }
+  }
+
+  // Try Expo: app.config.js (parse statically — look for common patterns)
+  if (!detected.bundleId) {
+    const appConfigJsPath = join(projectDir, 'app.config.js');
+    if (existsSync(appConfigJsPath)) {
+      try {
+        const src = readFileSync(appConfigJsPath, 'utf8');
+        detected.type = 'expo';
+
+        // Extract base app name (the production one, no Dev/Preview suffix)
+        const allNames = [...src.matchAll(/return\s+['"]([^'"]+)['"]/g)]
+          .map(m => m[1])
+          .filter(n => !n.includes('/') && !n.includes('.') && n.length < 50);
+        const prodName = allNames.find(n => !/ Dev$| Preview$| Staging$/i.test(n))
+          || allNames[allNames.length - 1];
+        if (prodName && !detected.appName) {
+          detected.appName = prodName;
+        }
+        if (!detected.appName) {
+          const nameMatch = src.match(/name:\s*['"]([^'"]+)['"]/m);
+          if (nameMatch) detected.appName = nameMatch[1];
+        }
+
+        // Extract base bundle ID (production, no suffix)
+        const bundleMatch = src.match(/return\s+['"]([a-zA-Z][a-zA-Z0-9]*(?:\.[a-zA-Z][a-zA-Z0-9]*){2,})['"]/m)
+          || src.match(/bundleIdentifier.*?['"]([a-zA-Z][a-zA-Z0-9]*(?:\.[a-zA-Z][a-zA-Z0-9]*){2,})['"]/m);
+        if (bundleMatch) {
+          // Try to find the base (production) bundle ID — the one without .dev or .preview
+          const allBundles = [...src.matchAll(/['"]([a-zA-Z][a-zA-Z0-9]*(?:\.[a-zA-Z][a-zA-Z0-9]*){2,})['"]/g)]
+            .map(m => m[1])
+            .filter(id => !id.endsWith('.dev') && !id.endsWith('.preview'));
+          detected.bundleId = allBundles[0] || bundleMatch[1];
+        }
+      } catch { /* ignore */ }
+    }
+  }
+
+  // Try eas.json for profile detection
+  const easJsonPath = join(projectDir, 'eas.json');
+  if (existsSync(easJsonPath)) {
+    detected.type = detected.type || 'expo';
+  }
+
+  // Try React Native (no Expo): look for android/app/build.gradle or ios/*.xcodeproj
+  if (!detected.type) {
+    if (existsSync(join(projectDir, 'android', 'app', 'build.gradle')) ||
+        existsSync(join(projectDir, 'ios'))) {
+      detected.type = 'react-native';
+    }
+  }
+
+  // Try package.json for app name fallback
+  if (!detected.appName) {
+    const pkgPath = join(projectDir, 'package.json');
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        detected.appName = pkg.name || null;
+      } catch { /* ignore */ }
+    }
+  }
+
+  return detected;
+}
+
+/**
+ * Detect build profiles from eas.json
+ */
+function detectProfiles(projectDir) {
+  const easJsonPath = join(projectDir, 'eas.json');
+  if (!existsSync(easJsonPath)) return null;
+
+  try {
+    const easJson = JSON.parse(readFileSync(easJsonPath, 'utf8'));
+    const build = easJson.build || {};
+    const profiles = {};
+
+    for (const [name, config] of Object.entries(build)) {
+      const env = config.env || {};
+      const variant = env.APP_VARIANT || name;
+
+      // Convention: dev → .dev suffix, preview → .preview, production → no suffix
+      let suffix = '';
+      if (variant === 'development' || variant === 'dev') suffix = '.dev';
+      else if (variant === 'preview' || variant === 'staging') suffix = '.preview';
+
+      profiles[name] = { bundle_id_suffix: suffix };
+    }
+
+    return Object.keys(profiles).length > 0 ? profiles : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function initCommand(options) {
+  const projectDir = options.dir || process.cwd();
+
+  console.log('');
+  console.log('🏭 Sloss — Project Setup');
+  console.log('════════════════════════════════════════');
+  console.log('');
+
+  // Check for existing .sloss.json
+  const slossPath = join(projectDir, '.sloss.json');
+  if (existsSync(slossPath)) {
+    const overwrite = await promptYesNo('.sloss.json already exists. Overwrite?', false);
+    if (!overwrite) {
+      console.log('Aborted.');
+      return;
+    }
+  }
+
+  // Step 1: Check login
+  let isLoggedIn = false;
+  try {
+    const creds = JSON.parse(readFileSync(CREDENTIALS_PATH, 'utf8'));
+    if (creds.apiKey) {
+      isLoggedIn = true;
+      console.log(`✅ Logged in as ${creds.email || 'unknown'}`);
+    }
+  } catch { /* not logged in */ }
+
+  if (!isLoggedIn) {
+    console.log('You need to log in to Sloss first.\n');
+    const baseUrl = options.url || 'https://sloss.ngrok.app';
+    await loginCommand({}, baseUrl);
+    console.log('');
+  }
+
+  // Step 2: Detect project
+  console.log('🔍 Detecting project...');
+  const detected = detectProject(projectDir);
+
+  if (detected.type) {
+    console.log(`   Found: ${detected.type} project`);
+  } else {
+    console.log('   Could not auto-detect project type.');
+  }
+
+  // Step 3: Prompt for app name and bundle ID
+  console.log('');
+  const appName = await prompt('App name', detected.appName || '');
+  const bundleId = await prompt('Bundle ID', detected.bundleId || '');
+
+  if (!appName || !bundleId) {
+    console.error('\n❌ App name and bundle ID are required.');
+    process.exit(1);
+  }
+
+  // Step 4: Build .sloss.json with conventions
+  const profiles = detectProfiles(projectDir) || {
+    development: { bundle_id_suffix: '.dev' },
+    preview: { bundle_id_suffix: '.preview' },
+    production: { bundle_id_suffix: '' },
+  };
+
+  const config = {
+    type: detected.type || 'expo',
+    app_name: appName,
+    bundle_id: bundleId,
+    version_file: 'app.version.json',
+    build_dir: '.',
+    ios_plist: 'ios/switchboard/Info.plist',
+    profiles,
+  };
+
+  // Try to find the actual iOS plist path
+  const plistCandidates = [
+    `ios/${appName.toLowerCase()}/Info.plist`,
+    `ios/${appName.replace(/\s+/g, '')}/Info.plist`,
+    `ios/${appName}/Info.plist`,
+  ];
+  for (const candidate of plistCandidates) {
+    if (existsSync(join(projectDir, candidate))) {
+      config.ios_plist = candidate;
+      break;
+    }
+  }
+
+  // If no ios_plist found, try a glob
+  if (!existsSync(join(projectDir, config.ios_plist))) {
+    try {
+      const { readdirSync } = await import('fs');
+      const iosDir = join(projectDir, 'ios');
+      if (existsSync(iosDir)) {
+        const dirs = readdirSync(iosDir, { withFileTypes: true })
+          .filter(d => d.isDirectory() && !d.name.startsWith('.') && d.name !== 'Pods' && d.name !== 'build');
+        for (const dir of dirs) {
+          const plist = join('ios', dir.name, 'Info.plist');
+          if (existsSync(join(projectDir, plist))) {
+            config.ios_plist = plist;
+            break;
+          }
+        }
+      }
+    } catch { /* ignore */ }
+  }
+
+  // Ensure version file exists
+  const versionFilePath = join(projectDir, 'app.version.json');
+  if (!existsSync(versionFilePath)) {
+    const createVersionFile = await promptYesNo('app.version.json not found. Create it?', true);
+    if (createVersionFile) {
+      writeFileSync(versionFilePath, JSON.stringify({ version: '1.0.0', buildNumber: '1' }, null, 2) + '\n');
+      console.log('   Created app.version.json');
+    }
+  }
+
+  // Write .sloss.json
+  writeFileSync(slossPath, JSON.stringify(config, null, 2) + '\n');
+
+  console.log('');
+  console.log('✅ Created .sloss.json');
+  console.log('');
+  console.log('   Next steps:');
+  console.log('   1. Commit .sloss.json to your repo');
+  console.log('   2. Run `sloss build` to queue your first build');
+  console.log('');
+}