@telepat/rilo 0.1.0

package/src/cli/commands/settingsFlow.js

@@ -0,0 +1,196 @@
+import { select, input, password, confirm } from '@inquirer/prompts';
+import { SETTINGS, SECURE_SETTINGS, PUBLIC_SETTINGS } from '../../config/settingsSchema.js';
+import {
+  resolvePublicValue,
+  resolveSecureStatus,
+  readPublicConfig,
+  savePublicSetting,
+  saveSecureToken
+} from '../../store/settingsStore.js';
+
+const DONE_CHOICE = '__done__';
+const CANCEL_CHOICE = '__cancel__';
+
+// ── Display helpers ────────────────────────────────────────────────────────────
+
+/**
+ * Format a value for display next to a setting name.
+ * Secure values are always masked; env-sourced values show an indicator.
+ */
+export function formatCurrentValue(setting, value, source) {
+  if (setting.type === 'secure') {
+    if (source === 'env') return '(set via environment variable — not editable here)';
+    if (source === 'keystore') return '(stored securely)';
+    return '(not set)';
+  }
+  if (source === 'env') return `${value}  ← from environment variable`;
+  const display = value !== undefined && value !== null ? String(value) : String(setting.default);
+  return source === 'default' ? `${display}  ← default` : display;
+}
+
+// ── Per-setting prompt ─────────────────────────────────────────────────────────
+
+async function promptForSetting(setting, currentValue, source) {
+  const isEnvOverridden = source === 'env';
+
+  if (setting.type === 'secure') {
+    if (isEnvOverridden) {
+      console.log(
+        `\n  ${setting.label}: This token is set via an environment variable and cannot be\n` +
+        '  overridden here. Remove it from your environment / .env file first.\n'
+      );
+      return null; // nothing to do
+    }
+
+    const hasExisting = source === 'keystore';
+    const action = await select({
+      message: `${setting.label}${hasExisting ? ' (currently stored securely)' : ' (not set)'}`,
+      choices: [
+        { name: hasExisting ? 'Replace stored value' : 'Set value', value: 'set' },
+        ...(hasExisting ? [{ name: 'Clear stored value', value: 'clear' }] : []),
+        { name: 'Skip', value: 'skip' }
+      ]
+    });
+
+    if (action === 'skip') return null;
+    if (action === 'clear') return { key: setting.keystoreKey, value: '', clear: true };
+
+    const value = await password({
+      message: `Enter ${setting.label}:`,
+      mask: '*',
+      validate(v) {
+        if (!v || !v.trim()) return 'Value must not be empty.';
+        return true;
+      }
+    });
+
+    return { key: setting.keystoreKey, value, secure: true };
+  }
+
+  // Public setting
+  if (isEnvOverridden) {
+    console.log(
+      `\n  ${setting.label}: Currently set to "${currentValue}" via environment variable.\n` +
+      '  rilo will use the env var value; any saved setting here will be ignored while\n' +
+      '  the env var is set.\n'
+    );
+    const proceed = await confirm({
+      message: 'Save a config.json value anyway (used when the env var is absent)?',
+      default: false
+    });
+    if (!proceed) return null;
+  }
+
+  const defaultDisplay = String(currentValue ?? setting.default);
+  const newValue = await input({
+    message: `${setting.label}:`,
+    default: defaultDisplay,
+    validate(v) {
+      if (setting.validate) return setting.validate(v);
+      return true;
+    }
+  });
+
+  // Coerce type
+  const coerced = setting.type === 'number' ? Number(newValue) : newValue;
+  return { key: setting.configKey, value: coerced, public: true };
+}
+
+// ── Main flow ─────────────────────────────────────────────────────────────────
+
+export async function openSettings() {
+  console.log('\n  rilo settings\n');
+
+  const storedConfig = await readPublicConfig();
+
+  // Resolve current state for all settings for menu display
+  const stateMap = {};
+  for (const s of SETTINGS) {
+    if (s.type === 'secure') {
+      const status = await resolveSecureStatus(s);
+      stateMap[s.id] = { value: null, source: status.source };
+    } else {
+      const resolved = resolvePublicValue(s, storedConfig);
+      stateMap[s.id] = resolved;
+    }
+  }
+
+  const pendingChanges = []; // { setting, change }
+
+  while (true) {
+    // Build menu choices
+    const choices = [
+      ...SECURE_SETTINGS.map((s) => {
+        const { source } = stateMap[s.id];
+        return {
+          name: `Secure: ${s.label}`,
+          value: s.id,
+          description: formatCurrentValue(s, null, source)
+        };
+      }),
+      ...PUBLIC_SETTINGS.map((s) => {
+        const { value, source } = stateMap[s.id];
+        return {
+          name: `General: ${s.label}`,
+          value: s.id,
+          description: formatCurrentValue(s, value, source)
+        };
+      }),
+      ...(pendingChanges.length > 0
+        ? [{ name: `✓ Save ${pendingChanges.length} change(s) and exit`, value: DONE_CHOICE }]
+        : [{ name: '✓ Done (no changes)', value: DONE_CHOICE }]),
+      { name: '✗ Cancel / Discard (Ctrl+C to quit)', value: CANCEL_CHOICE }
+    ];
+
+    const selected = await select({
+      message: 'Select a setting to edit (secure first, then general):',
+      choices,
+      pageSize: 20
+    });
+
+    if (selected === CANCEL_CHOICE) {
+      console.log('\n  No changes saved.\n');
+      return;
+    }
+
+    if (selected === DONE_CHOICE) break;
+
+    const setting = SETTINGS.find((s) => s.id === selected) ?? null;
+    if (!setting) continue;
+
+    const { value, source } = stateMap[setting.id];
+    const change = await promptForSetting(setting, value, source);
+
+    if (change) {
+      pendingChanges.push({ setting, change });
+      // Update display state optimistically
+      if (change.secure) {
+        stateMap[setting.id] = { value: null, source: 'keystore' };
+      } else if (change.clear) {
+        stateMap[setting.id] = { value: null, source: 'none' };
+      } else if (change.public) {
+        stateMap[setting.id] = { value: change.value, source: 'config' };
+      }
+    }
+  }
+
+  if (pendingChanges.length === 0) {
+    console.log('\n  No changes to save.\n');
+    return;
+  }
+
+  // Persist all changes
+  for (const { change } of pendingChanges) {
+    if (change.secure) {
+      await saveSecureToken(change.key, change.value);
+    } else if (change.clear) {
+      // Import deleteSecret lazily to avoid circular deps in tests
+      const { deleteSecret } = await import('../../config/keystore.js');
+      await deleteSecret(change.key);
+    } else if (change.public) {
+      await savePublicSetting(change.key, change.value);
+    }
+  }
+
+  console.log(`\n  Saved ${pendingChanges.length} change(s) to ~/.rilo/config.json / keystore.\n`);
+}

package/src/cli/index.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createJob } from '../store/jobStore.js';
+import { runPipeline } from '../pipeline/orchestrator.js';
+import {
+  ensureProject,
+  ensureProjectConfig,
+  projectStoryExists,
+  readProjectStory,
+  resolveProjectName,
+  writeProjectStory
+} from '../store/projectStore.js';
+import { openSettings } from './commands/settingsFlow.js';
+import { openHome } from './commands/openHome.js';
+import { applyStoredSettings } from '../config/env.js';
+
+function getArg(flag) {
+  const idx = process.argv.indexOf(flag);
+  if (idx === -1) return null;
+  return process.argv[idx + 1] || null;
+}
+
+function hasFlag(flag) {
+  return process.argv.includes(flag);
+}
+
+async function readCliVersion() {
+  try {
+    const cliDir = path.dirname(fileURLToPath(import.meta.url));
+    const packagePath = path.resolve(cliDir, '../../package.json');
+    const raw = await fs.readFile(packagePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return typeof parsed.version === 'string' ? parsed.version : 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+async function main() {
+  if (process.argv.includes('--version')) {
+    console.log(await readCliVersion());
+    return;
+  }
+
+  if (process.argv.includes('--help')) {
+    const helpText = `
+Rilo — Story-first vertical video generation
+
+USAGE
+  rilo --project <name> [--story-file <path>] [--force]
+  rilo settings
+  rilo home
+  rilo --help
+  rilo --version
+
+COMMANDS
+  rilo --project <name> [--story-file <path>] [--force]
+    Generate a complete video from a story
+    
+    --project <name>         Project identifier (required); creates projects/<name>/
+    --story-file <path>      Path to story text file (required on first run)
+    --force                  Force restart from earlier stages (use after config changes)
+
+  rilo settings
+    Configure API tokens, timeouts, and binary paths interactively
+
+  rilo home
+    Open ~/.rilo, the default home for projects and output files
+
+FLAGS
+  --help                     Show this help message
+  --version                  Show version information
+
+EXAMPLES
+  # First run: create project and generate
+  rilo --project wedding-case --story-file ./story.txt
+
+  # Subsequent runs: reuse saved story
+  rilo --project wedding-case
+
+  # Update config and regenerate
+  rilo --project wedding-case --force
+
+  # Configure settings
+  rilo settings
+
+  # Open the default Rilo home folder
+  rilo home
+
+  # Using npx (no installation needed)
+  npx @telepat/rilo --project wedding-case --story-file ./story.txt
+  npx @telepat/rilo home
+
+DOCUMENTATION
+  Quick start:          https://docs.telepat.io/rilo/getting-started/quickstart
+  CLI reference:        https://docs.telepat.io/rilo/reference/cli-reference
+  Configuration:        https://docs.telepat.io/rilo/guides/configuration
+  Troubleshooting:      https://docs.telepat.io/rilo/guides/troubleshooting
+  All docs:             https://docs.telepat.io/rilo/
+
+PROJECT OUTPUT
+  Generated files are stored in:
+  projects/<name>/
+  ├── config.json          Project settings (models, aspect ratio, duration, etc.)
+  ├── story.md             Formatted story
+  ├── final.mp4            Final video
+  ├── artifacts.json       Generation metadata (paths, durations, etc.)
+  ├── run-state.json       Checkpoint for resume/invalidation
+  ├── assets/              Keyframes, audio, video segments
+  └── logs/                Detailed generation logs
+
+SETTINGS
+  Configure via interactive menu:
+    rilo settings
+
+  Or with environment variables:
+    export RILO_REPLICATE_API_TOKEN=r8_xxxxx
+    export RILO_MAX_RETRIES=5
+    export PREDICTION_MAX_WAIT_MS=900000
+    rilo --project my-project --story-file ./story.txt
+
+  Settings precedence (highest to lowest):
+    1. Environment variable
+    2. ~/.rilo/config.json (saved via 'rilo settings')
+    3. Schema default
+
+INVOCATION METHODS
+  Global install:        rilo --project <name> --story-file <path>
+  No install (npx):      npx @telepat/rilo --project <name> --story-file <path>
+  Local development:     npm run dev -- --project <name> --story-file <path>
+`;
+    console.log(helpText);
+    return;
+  }
+
+  // `rilo settings` subcommand
+  if (process.argv[2] === 'settings') {
+    await openSettings();
+    return;
+  }
+
+  if (process.argv[2] === 'home') {
+    await openHome();
+    return;
+  }
+
+  // Merge stored settings (config.json + keystore) into env before running
+  await applyStoredSettings();
+
+  const projectArg = getArg('--project');
+  if (!projectArg) {
+    throw new Error('Missing --project argument');
+  }
+
+  const project = resolveProjectName(projectArg);
+  const forceRestart = hasFlag('--force');
+  const storyFile = getArg('--story-file');
+
+  await ensureProject(project);
+  await ensureProjectConfig(project);
+
+  let story;
+  const storyExists = await projectStoryExists(project);
+  if (storyExists) {
+    story = await readProjectStory(project);
+  } else if (storyFile) {
+    story = await fs.readFile(path.resolve(storyFile), 'utf8');
+    await writeProjectStory(project, story);
+  } else {
+    throw new Error('Project story.md not found. Provide --story-file once to initialize the project.');
+  }
+
+  const job = createJob({ story, project });
+  const result = await runPipeline(job.id, { forceRestart });
+
+  if (result.status !== 'completed') {
+    throw new Error(`Generation failed: ${result.error || 'unknown error'}`);
+  }
+
+  console.log(JSON.stringify({
+    jobId: result.id,
+    project,
+    finalVideoPath: result.artifacts.finalVideoPath
+  }, null, 2));
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

package/src/config/env.js

@@ -0,0 +1,158 @@
+/* c8 ignore file */
+import dotenv from 'dotenv';
+import os from 'node:os';
+import path from 'node:path';
+
+dotenv.config();
+
+const DEFAULT_APP_DIR = path.join(os.homedir(), '.rilo');
+
+export function parseEnvString(value, fallback) {
+  return typeof value === 'string' && value.length > 0 ? value : fallback;
+}
+
+export function hasEnvValue(value) {
+  return value !== undefined && value !== null && value !== '';
+}
+
+/* c8 ignore start */
+export function parseEnvNumber(value, fallback) {
+  if (!hasEnvValue(value)) {
+    return fallback;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+export function parseEnvBoolean(value, fallback = false) {
+  if (!hasEnvValue(value)) {
+    return fallback;
+  }
+  return String(value).toLowerCase() === 'true';
+}
+/* c8 ignore stop */
+
+export function parseAllowedHosts(value, fallback = 'replicate.delivery,replicate.com') {
+  return parseEnvString(value, fallback)
+    .split(',')
+    .map((entry) => entry.trim().toLowerCase())
+    .filter(Boolean);
+}
+
+export const env = {
+  replicateApiToken: parseEnvString(
+    process.env.SECRET_REPLICATE_API_TOKEN
+      || process.env.RILO_REPLICATE_API_TOKEN
+      || process.env.REPLICATE_API_TOKEN,
+    ''
+  ),
+  apiBearerToken: parseEnvString(
+    process.env.SECRET_API_BEARER_TOKEN
+      || process.env.RILO_API_BEARER_TOKEN
+      || process.env.API_BEARER_TOKEN,
+    ''
+  ),
+  port: parseEnvNumber(process.env.API_PORT || process.env.PORT, 3000),
+  webhookSecret: parseEnvString(process.env.WEBHOOK_SECRET, ''),
+  outputDir: parseEnvString(process.env.OUTPUT_DIR, path.join(DEFAULT_APP_DIR, 'output')),
+  projectsDir: parseEnvString(process.env.PROJECTS_DIR, path.join(DEFAULT_APP_DIR, 'projects')),
+  outputBackend: parseEnvString(
+    process.env.SECRET_OUTPUT_BACKEND
+      || process.env.RILO_OUTPUT_BACKEND
+      || process.env.OUTPUT_BACKEND,
+    'local'
+  ),
+  firebaseProjectId: parseEnvString(
+    process.env.SECRET_FIREBASE_PROJECT_ID
+      || process.env.RILO_FIREBASE_PROJECT_ID
+      || process.env.FIREBASE_PROJECT_ID,
+    ''
+  ),
+  firebaseStorageBucket: parseEnvString(
+    process.env.SECRET_FIREBASE_STORAGE_BUCKET
+      || process.env.RILO_FIREBASE_STORAGE_BUCKET
+      || process.env.FIREBASE_STORAGE_BUCKET,
+    ''
+  ),
+  firebaseClientEmail: parseEnvString(
+    process.env.RILO_FIREBASE_CLIENT_EMAIL
+      || process.env.FIREBASE_CLIENT_EMAIL,
+    ''
+  ),
+  firebasePrivateKey: parseEnvString(
+    process.env.RILO_FIREBASE_PRIVATE_KEY
+      || process.env.FIREBASE_PRIVATE_KEY,
+    ''
+  ),
+  useWebhooks: parseEnvBoolean(process.env.USE_WEBHOOKS, false),
+  maxRetries: parseEnvNumber(process.env.MAX_RETRIES, 2),
+  retryDelayMs: parseEnvNumber(process.env.RETRY_DELAY_MS, 2500),
+  predictionPollIntervalMs: parseEnvNumber(process.env.PREDICTION_POLL_INTERVAL_MS, 1500),
+  predictionMaxWaitMs: parseEnvNumber(process.env.PREDICTION_MAX_WAIT_MS, 600000),
+  downloadTimeoutMs: parseEnvNumber(process.env.DOWNLOAD_TIMEOUT_MS, 20000),
+  downloadMaxBytes: parseEnvNumber(process.env.DOWNLOAD_MAX_BYTES, 104857600),
+  downloadAllowedHosts: parseAllowedHosts(process.env.DOWNLOAD_ALLOWED_HOSTS),
+  apiDefaultLogsLimit: parseEnvNumber(process.env.API_DEFAULT_LOGS_LIMIT, 100),
+  apiMaxLogsLimit: parseEnvNumber(process.env.API_MAX_LOGS_LIMIT, 1000),
+  ffmpegBin: parseEnvString(process.env.FFMPEG_BIN, 'ffmpeg'),
+  ffprobeBin: parseEnvString(process.env.FFPROBE_BIN, 'ffprobe'),
+  ffsubsyncBin: parseEnvString(process.env.FFSUBSYNC_BIN, 'ffsubsync')
+};
+
+/**
+ * Merge stored settings (config.json + keystore) into the `env` object.
+ * Call this once at CLI/server startup, after env vars have been loaded.
+ *
+ * Precedence (highest → lowest):
+ *   1. Environment variables (already in `env` above — never overwritten)
+ *   2. ~/.rilo/config.json  (public settings)
+ *   3. OS keystore / encrypted file  (secure tokens)
+ *   4. Schema defaults (already reflected in `env` above)
+ */
+export async function applyStoredSettings() {
+  // Lazy imports to avoid circular deps and to keep env.js testable without FS
+  const { readPublicConfig } = await import('../store/settingsStore.js');
+  const { getSecret } = await import('./keystore.js');
+  const { PUBLIC_SETTINGS, SECURE_SETTINGS } = await import('./settingsSchema.js');
+
+  const storedConfig = await readPublicConfig();
+
+  // Apply public settings (only when no env var is set)
+  for (const setting of PUBLIC_SETTINGS) {
+    const hasEnvVar = setting.envNames.some((n) => process.env[n] !== undefined && process.env[n] !== '');
+    if (hasEnvVar) continue;
+
+    const stored = storedConfig[setting.configKey];
+    if (stored === undefined) continue;
+
+    // Map configKey → env property name (camelCase matches env object keys)
+    if (setting.id in env) {
+      env[setting.id] = setting.type === 'number' ? Number(stored) : stored;
+    }
+  }
+
+  // Apply secure tokens (only when no env var is set)
+  for (const setting of SECURE_SETTINGS) {
+    const hasEnvVar = setting.envNames.some((n) => process.env[n] !== undefined && process.env[n] !== '');
+    if (hasEnvVar) continue;
+
+    if (env[setting.id]) continue; // already has a value
+
+    const stored = await getSecret(setting.keystoreKey);
+    if (stored) {
+      env[setting.id] = stored;
+    }
+  }
+}
+
+export function assertRequiredEnv() {
+  if (!env.replicateApiToken) {
+    throw new Error('Missing REPLICATE_API_TOKEN in environment');
+  }
+}
+
+export function assertRequiredApiEnv() {
+  if (!env.apiBearerToken) {
+    throw new Error('Missing API_BEARER_TOKEN in environment');
+  }
+}