shipscreens 0.1.0

package/cli/commands/wizard.js

@@ -0,0 +1,266 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { OFFICIAL_TEMPLATES } from '../../src/constants/devices.js';
+import { runInit } from './init.js';
+import { buildTemplateConfig } from '../templateConfig.js';
+
+const DEVICE_PRESETS = [
+  { id: '1', label: 'iOS (iPhone 6.9")', devices: ['iphone69'] },
+  { id: '2', label: 'iOS (iPhone 6.9" + iPad 13")', devices: ['iphone69', 'ipad13'] },
+  { id: '3', label: 'Android (Pixel 8 phone)', devices: ['pixel8'] },
+  { id: '4', label: 'Android (Pixel 8 phone + Pixel Tablet)', devices: ['pixel8', 'pixeltablet'] },
+  { id: '5', label: 'iOS + Android (iPhone 6.9" + Pixel 8)', devices: ['iphone69', 'pixel8'] },
+  { id: '6', label: 'iOS + Android (iPhone 6.9" + iPad 13" + Pixel 8)', devices: ['iphone69', 'ipad13', 'pixel8'] },
+  { id: '7', label: 'Custom device ids', devices: null },
+];
+
+const parseList = (raw) =>
+  String(raw || '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+
+const HEX_COLOR = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i;
+
+const STYLE_FLOW_OPTIONS = [
+  { id: '1', label: 'Default (no style)', value: 'default' },
+  { id: '2', label: 'Pick a template', value: 'template' },
+  { id: '3', label: 'Custom (step-by-step)', value: 'custom' },
+];
+
+const LAYOUT_OPTIONS = [
+  { id: '1', label: 'Top (title above device)', value: 'top' },
+  { id: '2', label: 'Bottom (title below device)', value: 'bottom' },
+  { id: '3', label: 'Split (title left, device right)', value: 'split' },
+];
+
+const BADGE_OPTIONS = [
+  { id: '1', label: 'None', value: 'none' },
+  { id: '2', label: 'Stars', value: 'stars' },
+  { id: '3', label: 'Award', value: 'award' },
+  { id: '4', label: 'Download (App Store)', value: 'download' },
+  { id: '5', label: 'Google Play', value: 'googleplay' },
+];
+
+const FRAME_OPTIONS = [
+  { id: '1', label: 'Black', value: 'black' },
+  { id: '2', label: 'Silver', value: 'silver' },
+  { id: '3', label: 'Titanium', value: 'titanium' },
+  { id: '4', label: 'Blue', value: 'blue' },
+  { id: '5', label: 'Gold', value: 'gold' },
+];
+
+const FONT_OPTIONS = [
+  { id: '1', label: 'Inter', value: 'Inter' },
+  { id: '2', label: 'Roboto', value: 'Roboto' },
+  { id: '3', label: 'Montserrat', value: 'Montserrat' },
+  { id: '4', label: 'Playfair Display', value: 'Playfair Display' },
+  { id: '5', label: 'Merriweather', value: 'Merriweather' },
+  { id: '6', label: 'System', value: 'System' },
+];
+
+const BACKGROUND_OPTIONS = [
+  { id: '1', label: 'Solid color', value: 'solid' },
+  { id: '2', label: 'Gradient', value: 'gradient' },
+  { id: '3', label: 'Image (path)', value: 'image' },
+  { id: '4', label: 'Transparent', value: 'transparent' },
+];
+
+export async function runWizard({
+  dir = '.',
+  force = false,
+  presetStyle,
+  presetAssets,
+  skipStylePrompt = false,
+  locales: presetLocales,
+  slides: presetSlides,
+  devices: presetDevices,
+} = {}) {
+  if (!process.stdin.isTTY) {
+    throw new Error('Wizard requires an interactive terminal. Use shipscreens init --slides/--locales instead.');
+  }
+
+  const rl = readline.createInterface({ input, output });
+  const ask = async (prompt, defaultValue) => {
+    const suffix = defaultValue ? ` (${defaultValue})` : '';
+    const answer = (await rl.question(`${prompt}${suffix}: `)).trim();
+    return answer || defaultValue;
+  };
+
+  const askChoice = async (prompt, options, defaultId) => {
+    while (true) {
+      const raw = await ask(prompt, defaultId);
+      const normalized = String(raw || '').trim();
+      const match = options.find((opt) => opt.id === normalized || opt.value === normalized);
+      if (match) return match;
+      output.write(`  -> Choose one of: ${options.map((opt) => opt.id).join(', ')}.\n`);
+    }
+  };
+
+  const askYesNo = async (prompt, defaultValue = 'n') => {
+    while (true) {
+      const raw = await ask(prompt, defaultValue);
+      const normalized = String(raw || '').trim().toLowerCase();
+      if (['y', 'yes'].includes(normalized)) return true;
+      if (['n', 'no'].includes(normalized)) return false;
+      output.write('  -> Enter y or n.\n');
+    }
+  };
+
+  const askNumber = async (prompt, defaultValue, { min, max }) => {
+    while (true) {
+      const raw = await ask(prompt, String(defaultValue));
+      const value = Number(raw);
+      if (Number.isInteger(value) && value >= min && value <= max) return value;
+      output.write(`  -> Enter an integer between ${min} and ${max}.\n`);
+    }
+  };
+
+  const askFloat = async (prompt, defaultValue, { min, max }) => {
+    while (true) {
+      const raw = await ask(prompt, String(defaultValue));
+      const value = Number(raw);
+      if (Number.isFinite(value) && value >= min && value <= max) return value;
+      output.write(`  -> Enter a number between ${min} and ${max}.\n`);
+    }
+  };
+
+  const askHex = async (prompt, defaultValue) => {
+    while (true) {
+      const raw = await ask(prompt, defaultValue);
+      const value = String(raw || '').trim();
+      if (HEX_COLOR.test(value)) return value;
+      output.write('  -> Enter a hex color like #0f172a or #fff.\n');
+    }
+  };
+
+  try {
+    const targetDir = await ask('Project directory', dir || '.');
+    const localesRaw = await ask('Locales (comma-separated)', presetLocales || 'en-US');
+    const locales = parseList(localesRaw);
+    if (!locales.length) {
+      throw new Error('No locales provided. Example: en-US,ja-JP');
+    }
+
+    const parsedSlides = Number(presetSlides ?? 5);
+    const slideDefault = Number.isInteger(parsedSlides) && parsedSlides >= 1 && parsedSlides <= 10 ? parsedSlides : 5;
+    const slideCount = await askNumber('Slide count (1-10)', slideDefault, { min: 1, max: 10 });
+
+    let deviceIds;
+    const presetDeviceIds = Array.isArray(presetDevices)
+      ? presetDevices.map((item) => String(item || '').trim()).filter(Boolean)
+      : parseList(presetDevices);
+    if (presetDeviceIds.length) {
+      deviceIds = presetDeviceIds;
+    } else {
+      output.write('\nChoose a device preset:\n');
+      DEVICE_PRESETS.forEach((preset) => {
+        output.write(`  ${preset.id}) ${preset.label}\n`);
+      });
+      const presetChoice = await ask('Preset number', '5');
+      const preset = DEVICE_PRESETS.find((p) => p.id === presetChoice);
+      if (!preset) throw new Error('Invalid device preset selection.');
+
+      deviceIds = preset.devices;
+      if (!deviceIds) {
+        const custom = await ask('Device ids (comma-separated)', 'iphone69,pixel8');
+        deviceIds = parseList(custom);
+        if (!deviceIds.length) throw new Error('No device ids provided.');
+      }
+    }
+
+    let style = presetStyle;
+    let assets = presetAssets;
+    const shouldPromptStyle = !skipStylePrompt && !presetStyle && !presetAssets;
+
+    if (shouldPromptStyle) {
+      output.write('\nStyle setup:\n');
+      STYLE_FLOW_OPTIONS.forEach((option) => {
+        output.write(`  ${option.id}) ${option.label}\n`);
+      });
+      const styleMode = await askChoice('Style option', STYLE_FLOW_OPTIONS, '2');
+
+      if (styleMode.value === 'template') {
+        output.write('\nPick a starter template:\n');
+        output.write('  0) Default (no template)\n');
+        OFFICIAL_TEMPLATES.forEach((template, idx) => {
+          output.write(`  ${idx + 1}) ${template.name}\n`);
+        });
+        const templateChoiceRaw = await ask('Template number', '0');
+        const templateChoice = Number(templateChoiceRaw);
+        if (Number.isInteger(templateChoice) && templateChoice > 0) {
+          const template = OFFICIAL_TEMPLATES[templateChoice - 1];
+          if (!template) throw new Error('Invalid template selection.');
+          ({ style, assets } = buildTemplateConfig(template));
+        }
+      } else if (styleMode.value === 'custom') {
+        style = {};
+        assets = {};
+
+        output.write('\nLayout:\n');
+        const layoutChoice = await askChoice('Layout mode', LAYOUT_OPTIONS, '1');
+        style.layoutMode = layoutChoice.value;
+
+        const defaultSpacing = layoutChoice.value === 'split' ? 0 : 8;
+        style.topSpacing = await askNumber('Top spacing (0-30)', defaultSpacing, { min: 0, max: 30 });
+        style.deviceScale = await askFloat('Device scale (0.5-2.0)', 1.0, { min: 0.5, max: 2.0 });
+
+        output.write('\nTypography:\n');
+        const fontChoice = await askChoice('Font family', FONT_OPTIONS, '1');
+        style.selectedFont = fontChoice.value;
+        style.textColor = await askHex('Text color (hex)', '#1e293b');
+
+        const customizeSizes = await askYesNo('Customize header/subheader sizes? (y/n)', 'n');
+        if (customizeSizes) {
+          style.headerSize = await askNumber('Header size (24-200)', 96, { min: 24, max: 200 });
+          style.subHeaderSize = await askNumber('Subheader size (12-120)', 48, { min: 12, max: 120 });
+        }
+
+        output.write('\nBadges + frame:\n');
+        const badgeChoice = await askChoice('Badge type', BADGE_OPTIONS, '1');
+        style.badgeType = badgeChoice.value;
+        const frameChoice = await askChoice('Frame color', FRAME_OPTIONS, '1');
+        style.frameColor = frameChoice.value;
+
+        output.write('\nBackground:\n');
+        const bgChoice = await askChoice('Background type', BACKGROUND_OPTIONS, '1');
+        if (bgChoice.value === 'solid') {
+          assets.background = { type: 'solid', color: await askHex('Background color (hex)', '#0f172a') };
+        } else if (bgChoice.value === 'gradient') {
+          const start = await askHex('Gradient start (hex)', '#0f172a');
+          const end = await askHex('Gradient end (hex)', '#1e293b');
+          const angle = await askNumber('Gradient angle (0-360)', 135, { min: 0, max: 360 });
+          assets.background = { type: 'gradient', start, end, angle };
+        } else if (bgChoice.value === 'image') {
+          const bgPath = await ask('Background image path (relative)', 'assets/background.png');
+          const blur = await askNumber('Background blur (0-64)', 0, { min: 0, max: 64 });
+          const opacity = await askNumber('Background dim (0-100)', 0, { min: 0, max: 100 });
+          assets.background = { type: 'image', path: bgPath, blur, opacity };
+        } else if (bgChoice.value === 'transparent') {
+          assets.background = { type: 'transparent' };
+        }
+
+        if (!Object.keys(assets).length) assets = undefined;
+      }
+    }
+
+    const wantsLogo = await askYesNo('Add a logo image? (y/n)', 'n');
+    if (wantsLogo) {
+      if (!assets) assets = {};
+      const logoPath = await ask('Logo image path (relative)', 'assets/logo.png');
+      assets.logo = { path: logoPath };
+    }
+
+    return await runInit({
+      dir: targetDir,
+      slides: slideCount,
+      locales: locales.join(','),
+      devices: deviceIds,
+      assets,
+      style,
+      force,
+    });
+  } finally {
+    rl.close();
+  }
+}

package/cli/dataUrl.js

@@ -0,0 +1,19 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const MIME_BY_EXT = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.webp': 'image/webp',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+};
+
+export async function fileToDataUrl(absoluteFilePath) {
+  const buffer = await fs.readFile(absoluteFilePath);
+  const ext = path.extname(absoluteFilePath).toLowerCase();
+  const mime = MIME_BY_EXT[ext] || 'application/octet-stream';
+  return `data:${mime};base64,${buffer.toString('base64')}`;
+}
+

package/cli/fastlaneZip.js

@@ -0,0 +1,115 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import AdmZip from 'adm-zip';
+
+function compareStrings(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+
+const ZIP_MIN_DATE = new Date(1980, 0, 1, 0, 0, 0);
+
+export function resolveDeterministicZipDate(sourceDateEpoch = process.env.SOURCE_DATE_EPOCH) {
+  if (!sourceDateEpoch) return ZIP_MIN_DATE;
+
+  const parsed = typeof sourceDateEpoch === 'string' ? Number.parseInt(sourceDateEpoch, 10) : Number(sourceDateEpoch);
+  if (!Number.isFinite(parsed) || parsed <= 0) return ZIP_MIN_DATE;
+
+  const utc = new Date(parsed * 1000);
+  const localLikeUtc = new Date(
+    utc.getUTCFullYear(),
+    utc.getUTCMonth(),
+    utc.getUTCDate(),
+    utc.getUTCHours(),
+    utc.getUTCMinutes(),
+    utc.getUTCSeconds()
+  );
+
+  if (localLikeUtc.getFullYear() < 1980) return ZIP_MIN_DATE;
+  return localLikeUtc;
+}
+
+async function dirExists(dirPath) {
+  try {
+    const stat = await fs.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+async function listFilesRecursive(rootDir) {
+  const results = [];
+
+  async function walk(currentDir) {
+    const entries = await fs.readdir(currentDir, { withFileTypes: true });
+    entries.sort((a, b) => compareStrings(a.name, b.name));
+
+    for (const entry of entries) {
+      const absPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(absPath);
+        continue;
+      }
+      if (entry.isFile()) {
+        results.push(absPath);
+      }
+    }
+  }
+
+  await walk(rootDir);
+  return results.map((absPath) => {
+    const rel = path.relative(rootDir, absPath);
+    const posix = rel.split(path.sep).join('/');
+    return { absPath, relPath: posix };
+  });
+}
+
+export async function writeFastlaneZip({ iosDir, androidDir, outZipPath, sourceDateEpoch } = {}) {
+  const entries = [];
+
+  if (iosDir && (await dirExists(iosDir))) {
+    const files = await listFilesRecursive(iosDir);
+    files.forEach((file) => {
+      entries.push({
+        absPath: file.absPath,
+        entryName: path.posix.join('fastlane', 'screenshots', file.relPath),
+      });
+    });
+  }
+
+  if (androidDir && (await dirExists(androidDir))) {
+    const files = await listFilesRecursive(androidDir);
+    files.forEach((file) => {
+      entries.push({
+        absPath: file.absPath,
+        entryName: path.posix.join('fastlane', 'metadata', 'android', file.relPath),
+      });
+    });
+  }
+
+  if (!entries.length) {
+    throw new Error('No output files found to zip.');
+  }
+
+  entries.sort((a, b) => compareStrings(a.entryName, b.entryName));
+
+  const zip = new AdmZip();
+  const fixedDate = resolveDeterministicZipDate(sourceDateEpoch);
+
+  for (const entry of entries) {
+    const dir = path.posix.dirname(entry.entryName);
+    const zipPath = dir === '.' ? '' : dir;
+    const zipName = path.posix.basename(entry.entryName);
+
+    zip.addLocalFile(entry.absPath, zipPath, zipName);
+    const zipEntry = zip.getEntry(entry.entryName);
+    if (zipEntry?.header) {
+      zipEntry.header.time = fixedDate;
+    }
+  }
+
+  await fs.mkdir(path.dirname(outZipPath), { recursive: true });
+  zip.writeZip(outZipPath);
+}
+

package/cli/hash.js

@@ -0,0 +1,13 @@
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+
+export async function sha256File(absoluteFilePath) {
+  return await new Promise((resolve, reject) => {
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(absoluteFilePath);
+    stream.on('error', reject);
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('end', () => resolve(hash.digest('hex')));
+  });
+}
+

package/cli/loadConfig.js

@@ -0,0 +1,55 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+import { ShipScreensConfigSchema } from './schema.js';
+
+function formatZodIssuePath(issuePath) {
+  if (!Array.isArray(issuePath) || !issuePath.length) return '(root)';
+  return issuePath
+    .map((segment) => (typeof segment === 'number' ? `[${segment}]` : String(segment)))
+    .join('.')
+    .replaceAll('.[', '[');
+}
+
+export function formatZodError(error) {
+  const issues = error?.issues || [];
+  return issues
+    .map((issue) => `${formatZodIssuePath(issue.path)}: ${issue.message}`)
+    .join('\n');
+}
+
+export async function resolveDefaultConfigPath(cwd = process.cwd()) {
+  const candidates = ['shipscreens.config.yml', 'shipscreens.config.yaml'];
+  for (const name of candidates) {
+    const full = path.join(cwd, name);
+    try {
+      await fs.access(full);
+      return full;
+    } catch {
+      // continue
+    }
+  }
+  return null;
+}
+
+export async function loadShipScreensConfig(configPath) {
+  const absoluteConfigPath = path.resolve(process.cwd(), configPath);
+  const raw = await fs.readFile(absoluteConfigPath, 'utf8');
+
+  let parsed;
+  try {
+    parsed = YAML.parse(raw);
+  } catch (err) {
+    const msg = err?.message || String(err);
+    throw new Error(`Failed to parse YAML: ${msg}`);
+  }
+
+  const result = ShipScreensConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(`Config schema validation failed:\n${formatZodError(result.error)}`);
+  }
+
+  const configDir = path.dirname(absoluteConfigPath);
+  return { config: result.data, configDir, configPath: absoluteConfigPath };
+}
+

package/cli/outputPaths.js

@@ -0,0 +1,24 @@
+import path from 'node:path';
+
+export function resolveOutRoot({ configDir, outDir } = {}) {
+  if (!configDir) throw new Error('configDir is required');
+  const raw = String(outDir || '').trim();
+  if (!raw) return configDir;
+  if (path.isAbsolute(raw)) return raw;
+  return path.resolve(configDir, raw);
+}
+
+export function resolveOutputPath({ outRoot, value, fallback }) {
+  const raw = String(value || fallback || '').trim();
+  if (!raw) throw new Error('Output path is required');
+  if (path.isAbsolute(raw)) return raw;
+  return path.resolve(outRoot, raw);
+}
+
+export function resolveZipOutPath({ outRoot, zipOut }) {
+  const raw = String(zipOut || '').trim();
+  if (!raw) return path.join(outRoot, 'fastlane_assets.zip');
+  if (path.isAbsolute(raw)) return raw;
+  return path.resolve(outRoot, raw);
+}
+

package/cli/packageRoot.js

@@ -0,0 +1,8 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export function getPackageRoot() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return path.resolve(here, '..');
+}
+

package/cli/pathUtils.js

@@ -0,0 +1,25 @@
+import path from 'node:path';
+
+export function toPosixPath(value) {
+  return String(value).replaceAll('\\', '/');
+}
+
+export function normalizeRepoRelativePath(value) {
+  const trimmed = String(value ?? '').trim();
+  const posix = toPosixPath(trimmed);
+  const stripped = posix.startsWith('./') ? posix.slice(2) : posix;
+  const normalized = path.posix.normalize(stripped);
+  return normalized === '.' ? '' : normalized;
+}
+
+export function isDisallowedPath(value) {
+  const raw = String(value ?? '').trim();
+  if (!raw) return true;
+
+  const posix = toPosixPath(raw);
+  if (/^[a-z]+:\/\//i.test(posix)) return true; // URL
+  if (/^data:/i.test(posix)) return true; // data URL
+  if (posix.startsWith('/') || posix.startsWith('\\')) return true; // absolute (posix/UNC-ish)
+  if (/^[a-zA-Z]:[\\/]/.test(raw)) return true; // Windows drive absolute
+  return false;
+}

package/cli/rendererServer.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { startStaticServer } from './staticServer.js';
+import { startViteServer } from './viteServer.js';
+
+const DEFAULT_REMOTE_RENDERER_BASE_URL = 'https://shipscreens.com';
+
+async function fileExists(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+
+function normalizeBaseUrl(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return '';
+  if (raw.toLowerCase() === 'off') return '';
+  return raw.replace(/\/+$/, '');
+}
+
+export async function startRendererServer({ packageRoot }) {
+  const distDir = path.join(packageRoot, 'dist');
+  const indexPath = path.join(distDir, 'index.html');
+  const remoteBaseUrl = normalizeBaseUrl(process.env.SHIPSCREENS_RENDERER_BASE_URL) || DEFAULT_REMOTE_RENDERER_BASE_URL;
+  try {
+    return await startViteServer({ rootDir: packageRoot });
+  } catch (err) {
+    if (await fileExists(indexPath)) {
+      return await startStaticServer({ distDir });
+    }
+
+    // When installed via `npx` (GitHub) or in other "source-only" setups,
+    // devDependencies (vite) and build artifacts (dist/) may be absent.
+    // Fall back to the hosted renderer so the CLI still works end-to-end.
+    if (remoteBaseUrl) {
+      return {
+        baseUrl: remoteBaseUrl,
+        close: async () => {},
+        mode: 'remote',
+      };
+    }
+
+    throw err;
+  }
+}

package/cli/repoRoot.js

@@ -0,0 +1,23 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+async function hasGitMarker(dir) {
+  const gitPath = path.join(dir, '.git');
+  try {
+    const stat = await fs.lstat(gitPath);
+    return stat.isDirectory() || stat.isFile() || stat.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+export async function findRepoRoot(startDir) {
+  let dir = path.resolve(startDir);
+  while (dir) {
+    if (await hasGitMarker(dir)) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return startDir;
+}

package/cli/rootPolicy.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { findRepoRoot } from './repoRoot.js';
+
+export function isPathInsideRoot({ rootPath, candidatePath }) {
+  const relative = path.relative(rootPath, candidatePath);
+  if (!relative) return true;
+  if (path.isAbsolute(relative)) return false;
+  return relative !== '..' && !relative.startsWith(`..${path.sep}`);
+}
+
+export async function resolveValidationRoot({ configDir }) {
+  const repoRoot = await findRepoRoot(configDir);
+  const rootRealPath = await fs.realpath(repoRoot);
+  return { rootPath: repoRoot, rootRealPath };
+}
+