nivii 0.2.4 → 0.3.0

package/dist/cli.js

@@ -92,7 +92,7 @@ cli
     .action(async (slug) => {
     await runAnalytics(slug);
 });
-cli.version('0.1.8');
+cli.version('0.2.0');
 // ─── Show help when no command given ─────────────────────────────────────────
 cli.parse(process.argv, { run: false });
 if (!cli.matchedCommand) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nivii",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "⚡ The fastest, most beautiful way to share any local project via a live URL",
   "type": "module",
   "bin": {
@@ -45,8 +45,7 @@
     "url": "https://github.com/Aadigarg111/Nivi-sh.git"
   },
   "homepage": "https://nivii.app",
-  "author": {
-    "name": "Aadi Garg",
-    "email": "contact@aadigarg.in"
+  "bugs": {
+    "url": "mailto:contact@nivii.app"
   }
 }

package/src/cli.ts

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+import { cac } from 'cac';
+import chalk from 'chalk';
+import { runShare } from './commands/share.js';
+import { runConfig } from './commands/config.js';
+import { runWhoami } from './commands/whoami.js';
+import { runAnalytics } from './core/analytics.js';
+import { loadConfig, updateConfig } from './utils/config.js';
+import { showWelcome, showHelp } from './ui/welcome.js';
+
+const cli = cac('nivii');
+
+// ─── First run ────────────────────────────────────────────────────────────────
+const config = loadConfig();
+if (config.firstRun) {
+  showWelcome();
+  updateConfig({ firstRun: false });
+}
+
+// ─── share ────────────────────────────────────────────────────────────────────
+cli
+  .command('share', 'Deploy your project and get a live URL')
+  .option('--dir <dir>', 'Directory to deploy (default: cwd)')
+  .option('--slug <slug>', 'Custom slug (Pro) e.g. my-demo → my-demo.nivii.app')
+  .option('--pass <password>', 'Password-protect your deployment')
+  .option('--otp', 'Enable one-time password access')
+  .option('--expires <duration>', 'Expiry: 1h / 24h / 7d / 30d / never')
+  .option('--live', 'Enable live sync (watch & auto-redeploy on changes)')
+  .option('--collab', 'Enable real-time collaborative preview (Pro)')
+  .option('--no-build', 'Skip build, use existing output directory')
+  .option('--cmd <cmd>', 'Custom build command')
+  .option('--port <port>', 'Port for server-mode proxy', { default: 3000 })
+  .option('--max-views <n>', 'Self-destruct after N views')
+  .option('--self-destruct', 'Self-destruct after first view')
+  .option('--no-qr', 'Skip QR code')
+  .option('--no-open', 'Do not open browser')
+  .action(async (options) => {
+    try {
+      await runShare({
+        dir: options.dir,
+        slug: options.slug,
+        pass: options.pass,
+        otp: options.otp,
+        expires: options.expires,
+        live: options.live,
+        collab: options.collab,
+        noBuild: options['no-build'],
+        cmd: options.cmd,
+        port: options.port,
+        maxViews: options.maxViews,
+        selfDestruct: options.selfDestruct,
+        open: options.open,
+        qr: options.qr,
+      });
+    } catch (err: any) {
+      console.error(chalk.red('\n  ✗ ') + err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── config ───────────────────────────────────────────────────────────────────
+cli
+  .command('config [key] [value]', 'View or set config values')
+  .action((key, value) => {
+    runConfig(key, value);
+  });
+
+// ─── whoami ───────────────────────────────────────────────────────────────────
+cli
+  .command('whoami', 'Show current account info')
+  .action(() => {
+    runWhoami();
+  });
+
+// ─── ls (list deployments) ────────────────────────────────────────────────────
+cli
+  .command('ls', 'List your recent deployments')
+  .action(() => {
+    const cfg = loadConfig();
+    const deployments = cfg.deployments || [];
+    if (!deployments.length) {
+      console.log(chalk.hex('#6B7280')('\n  No deployments yet. Run: nivii share\n'));
+      return;
+    }
+    console.log('');
+    console.log(chalk.hex('#A78BFA')('  Recent Deployments'));
+    console.log('');
+    deployments.forEach((d) => {
+      const age = timeSince(new Date(d.createdAt));
+      console.log(`  ${chalk.cyan(d.slug)} · ${chalk.underline(d.url)} · ${chalk.hex('#6B7280')(age)}`);
+    });
+    console.log('');
+  });
+
+// ─── analytics ────────────────────────────────────────────────────────────────
+cli
+  .command('analytics [slug]', 'View analytics for a deployment')
+  .action(async (slug) => {
+    await runAnalytics(slug);
+  });
+
+cli.version('0.1.8');
+
+// ─── Show help when no command given ─────────────────────────────────────────
+cli.parse(process.argv, { run: false });
+if (!cli.matchedCommand) {
+  showHelp();
+  process.exit(0);
+}
+await cli.runMatchedCommand();
+
+function timeSince(date: Date): string {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+  if (seconds < 60) return `${seconds}s ago`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}

package/src/commands/config.ts

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import { loadConfig, saveConfig } from '../utils/config.js';
+import { theme } from '../ui/theme.js';
+
+export function runConfig(key?: string, value?: string) {
+  const config = loadConfig();
+
+  if (!key) {
+    console.log('');
+    console.log(theme.primary('  Nivii Config') + theme.muted(' (~/.nivii/config.json)'));
+    console.log('');
+    Object.entries(config).forEach(([k, v]) => {
+      if (k === 'token') {
+        console.log(`  ${chalk.cyan(k)}: ${chalk.hex('#6B7280')('[hidden]')}`);
+      } else if (k === 'deployments') {
+        console.log(`  ${chalk.cyan(k)}: ${chalk.hex('#6B7280')(JSON.stringify(v).slice(0, 60) + '…')}`);
+      } else {
+        console.log(`  ${chalk.cyan(k)}: ${chalk.white(String(v))}`);
+      }
+    });
+    console.log('');
+    return;
+  }
+
+  if (value === undefined) {
+    console.log(`  ${chalk.cyan(key)}: ${chalk.white(String((config as any)[key] ?? 'not set'))}`);
+    return;
+  }
+
+  (config as any)[key] = value;
+  saveConfig(config);
+  console.log(theme.success(`  ✓ Set ${key} = ${value}`));
+}

package/src/commands/share.ts

@@ -0,0 +1,159 @@
+import path from 'path';
+import chalk from 'chalk';
+import { detectFramework } from '../core/detect.js';
+import { runBuild } from '../core/build.js';
+import { uploadDeploy } from '../core/upload.js';
+import { generateSlug } from '../utils/hash.js';
+import { loadConfig, updateConfig } from '../utils/config.js';
+import { showQR, copyToClipboard, openBrowser } from '../core/qr.js';
+import { startLiveSync } from '../core/tunnel.js';
+import { showBanner } from '../ui/welcome.js';
+import { step, success, warn } from '../ui/spinner.js';
+import { theme } from '../ui/theme.js';
+
+export interface ShareOptions {
+  dir?: string;
+  slug?: string;
+  pass?: string;
+  otp?: boolean;
+  expires?: string;
+  live?: boolean;
+  collab?: boolean;
+  noBuild?: boolean;
+  cmd?: string;
+  port?: number;
+  maxViews?: number;
+  selfDestruct?: boolean;
+  open?: boolean;
+  qr?: boolean;
+}
+
+export async function runShare(opts: ShareOptions) {
+  showBanner();
+
+  const cwd = opts.dir ? path.resolve(opts.dir) : process.cwd();
+  const config = loadConfig();
+
+  // ─── 1. Detect framework ───────────────────────────────────────────────────
+  step('🔍', 'Detecting project type…', cwd);
+  const detected = detectFramework(cwd);
+
+  const frameworkLabel: Record<string, string> = {
+    nextjs: 'Next.js', vite: 'Vite', 'react-cra': 'React (CRA)',
+    vue: 'Vue', svelte: 'Svelte', sveltekit: 'SvelteKit',
+    astro: 'Astro', remix: 'Remix', nuxt: 'Nuxt',
+    solid: 'Solid.js', express: 'Express', fastify: 'Fastify',
+    hono: 'Hono', static: 'Static HTML', unknown: 'Unknown',
+  };
+
+  success(`Detected ${chalk.cyan(frameworkLabel[detected.framework] || detected.framework)} ` +
+    `${theme.muted(`(${detected.confidence}% confidence)`)}`);
+
+  if (detected.framework === 'unknown' && !opts.noBuild) {
+    warn('Could not detect framework. Using current directory as static site.');
+  }
+
+  // ─── 2. Build ──────────────────────────────────────────────────────────────
+  const { outputDir } = await runBuild({
+    cwd,
+    detect: detected,
+    customCmd: opts.cmd,
+    noBuild: opts.noBuild,
+  });
+
+  const fullOutputDir = path.resolve(cwd, outputDir);
+
+  // ─── 3. Slug ───────────────────────────────────────────────────────────────
+  let slug = opts.slug;
+  if (!slug) {
+    slug = generateSlug(8);
+  } else if (config.plan !== 'pro') {
+    warn('Custom slugs require Nivii Pro. Using random slug instead.');
+    slug = generateSlug(8);
+  }
+
+  // ─── 4. Upload (files directly, no zip) ────────────────────────────────────
+  const deployResult = await uploadDeploy({
+    buildDir: fullOutputDir,
+    slug,
+    token: config.token,
+    password: opts.pass,
+    otp: opts.otp,
+    expires: opts.expires || (config.plan === 'pro' ? undefined : '48h'),
+    live: opts.live,
+    collab: opts.collab,
+    maxViews: opts.maxViews,
+    selfDestruct: opts.selfDestruct,
+  });
+
+  // ─── 5. Save to config ─────────────────────────────────────────────────────
+  const deployments = config.deployments || [];
+  deployments.unshift({
+    slug: deployResult.slug,
+    url: deployResult.url,
+    createdAt: new Date().toISOString(),
+    expiresAt: deployResult.expiresAt,
+  });
+  updateConfig({ deployments: deployments.slice(0, 20) });
+
+  // ─── 6. Output ─────────────────────────────────────────────────────────────
+  console.log('');
+  console.log(theme.box([
+    theme.accent('  🚀  Your project is live!'),
+    '',
+    '  ' + theme.primary('URL:') + '  ' + chalk.underline.cyan(deployResult.url),
+    ...(deployResult.expiresAt ? ['  ' + theme.muted('Expires:') + '  ' + theme.muted(new Date(deployResult.expiresAt).toLocaleString())] : []),
+    ...(opts.pass ? ['  ' + theme.muted('Protected:') + '  ' + theme.success('✓ Password')] : []),
+    ...(opts.otp && deployResult.otpCode ? ['  ' + theme.muted('OTP:') + '  ' + theme.warning(deployResult.otpCode)] : []),
+    ...(opts.live ? ['  ' + theme.muted('Live sync:') + '  ' + theme.success('✓ Active')] : []),
+    ...(opts.collab ? ['  ' + theme.muted('Collab:') + '  ' + theme.success('✓ Active')] : []),
+  ]));
+  console.log('');
+
+  // ─── 7. Copy URL to clipboard ──────────────────────────────────────────────
+  const copied = await copyToClipboard(deployResult.url);
+  if (copied) {
+    success('URL copied to clipboard');
+  }
+
+  // ─── 8. QR code ────────────────────────────────────────────────────────────
+  if (opts.qr !== false) {
+    await showQR(deployResult.url);
+  }
+
+  // ─── 9. Open browser ───────────────────────────────────────────────────────
+  if (opts.open !== false) {
+    await openBrowser(deployResult.url);
+  }
+
+  // ─── 10. Live sync ─────────────────────────────────────────────────────────
+  if (opts.live && deployResult.liveToken) {
+    console.log('');
+    console.log(theme.accent('  ⚡ Live Sync Active') + theme.muted(' — watching for changes…'));
+    console.log(theme.muted('  Press Ctrl+C to stop'));
+    console.log('');
+
+    const stopLive = startLiveSync({
+      watchDir: fullOutputDir,
+      slug: deployResult.slug,
+      liveToken: deployResult.liveToken,
+      onUpdate: async () => {
+        await uploadDeploy({
+          buildDir: fullOutputDir,
+          slug: deployResult.slug,
+          token: config.token,
+          live: true,
+        });
+      },
+    });
+
+    process.on('SIGINT', () => {
+      stopLive();
+      console.log('');
+      console.log(theme.muted('  ↳ Live sync stopped'));
+      process.exit(0);
+    });
+
+    await new Promise(() => {});
+  }
+}

package/src/commands/whoami.ts

@@ -0,0 +1,16 @@
+import chalk from 'chalk';
+import { loadConfig } from '../utils/config.js';
+import { theme } from '../ui/theme.js';
+
+export function runWhoami() {
+  const config = loadConfig();
+  console.log('');
+  if (!config.token) {
+    console.log(theme.muted('  Not logged in. Using anonymous mode.'));
+    console.log('  ' + theme.accent('nivii login') + theme.muted(' to unlock Pro features.'));
+  } else {
+    console.log(theme.success('  ✓ Logged in'));
+    console.log('  ' + chalk.cyan('Plan: ') + chalk.white(config.plan || 'free'));
+  }
+  console.log('');
+}

package/src/core/analytics.ts

@@ -0,0 +1,64 @@
+/**
+ * Nivii Analytics — View deployment analytics
+ */
+import { loadConfig } from '../utils/config.js';
+import { theme } from '../ui/theme.js';
+import chalk from 'chalk';
+
+export interface AnalyticsData {
+  views: number;
+  sessions: Array<{
+    timestamp: string;
+    country: string;
+    city: string;
+    ua: string;
+  }>;
+}
+
+export async function runAnalytics(slug?: string) {
+  const config = loadConfig();
+  const apiBase = config.apiBase || 'https://api.nivii.app';
+
+  if (!slug) {
+    const deployments = config.deployments || [];
+    if (!deployments.length) {
+      console.log(theme.muted('\n  No deployments found. Run: nivii share\n'));
+      return;
+    }
+    slug = deployments[0].slug;
+  }
+
+  console.log('');
+  console.log(theme.primary('  Analytics') + theme.muted(` for ${slug}.nivii.app`));
+  console.log('');
+
+  try {
+    const { default: fetch } = await import('node-fetch');
+    const res = await fetch(`${apiBase}/analytics/${slug}`, {
+      headers: config.token ? { Authorization: `Bearer ${config.token}` } : {},
+    });
+
+    if (!res.ok) {
+      console.log(theme.error('  Failed to fetch analytics: ' + res.status));
+      return;
+    }
+
+    const data = await res.json() as AnalyticsData;
+
+    console.log('  ' + chalk.cyan('Total views:') + '  ' + chalk.white(String(data.views)));
+    console.log('');
+
+    if (data.sessions && data.sessions.length > 0) {
+      console.log('  ' + theme.muted('Recent visitors:'));
+      console.log('');
+      data.sessions.slice(-10).reverse().forEach(s => {
+        const time = new Date(s.timestamp).toLocaleString();
+        console.log(`  ${chalk.hex('#6B7280')(time)}  ${chalk.cyan(s.country)}/${chalk.white(s.city)}`);
+      });
+    }
+
+    console.log('');
+  } catch (err: any) {
+    console.log(theme.error('  ' + err.message));
+  }
+}

package/src/core/build.ts

@@ -0,0 +1,46 @@
+import { spawn } from 'child_process';
+import type { DetectResult } from './detect.js';
+import { createSpinner, step } from '../ui/spinner.js';
+import chalk from 'chalk';
+
+export interface BuildOptions {
+  cwd: string;
+  detect: DetectResult;
+  customCmd?: string;
+  noBuild?: boolean;
+}
+
+export async function runBuild(opts: BuildOptions): Promise<{ outputDir: string }> {
+  const { cwd, detect, customCmd, noBuild } = opts;
+
+  if (noBuild || detect.buildCommand === null) {
+    step('📁', 'Skipping build', detect.outputDir);
+    return { outputDir: detect.outputDir };
+  }
+
+  const cmd = customCmd || detect.buildCommand;
+  const spinner = createSpinner(`Building with ${chalk.cyan(detect.framework)}…`);
+  spinner.start();
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, [], {
+      cwd,
+      shell: true,
+      env: { ...process.env, NODE_ENV: 'production', CI: '1' },
+    });
+
+    let stderr = '';
+    proc.stderr.on('data', d => { stderr += d.toString(); });
+
+    proc.on('close', code => {
+      if (code === 0) {
+        spinner.succeed(chalk.hex('#10B981')(`Build complete `) + chalk.hex('#6B7280')(`(${detect.framework})`));
+        resolve({ outputDir: detect.outputDir });
+      } else {
+        spinner.fail(chalk.hex('#EF4444')('Build failed'));
+        console.log(chalk.hex('#6B7280')(stderr.slice(-800)));
+        reject(new Error(`Build exited with code ${code}`));
+      }
+    });
+  });
+}

package/src/core/detect.ts

@@ -0,0 +1,159 @@
+import fs from 'fs';
+import path from 'path';
+
+export type Framework =
+  | 'nextjs'
+  | 'vite'
+  | 'react-cra'
+  | 'vue'
+  | 'svelte'
+  | 'sveltekit'
+  | 'astro'
+  | 'remix'
+  | 'nuxt'
+  | 'solid'
+  | 'express'
+  | 'fastify'
+  | 'hono'
+  | 'static'
+  | 'unknown';
+
+export interface DetectResult {
+  framework: Framework;
+  buildCommand: string | null;
+  outputDir: string;
+  isServer: boolean;
+  port?: number;
+  packageManager: 'npm' | 'pnpm' | 'yarn' | 'bun';
+  confidence: number; // 0-100
+}
+
+export function detectFramework(cwd: string): DetectResult {
+  const pkg = readJson(path.join(cwd, 'package.json'));
+  const deps = {
+    ...(pkg?.dependencies || {}),
+    ...(pkg?.devDependencies || {}),
+  };
+
+  const has = (name: string) => name in deps;
+  const hasFile = (...files: string[]) =>
+    files.some(f => fs.existsSync(path.join(cwd, f)));
+
+  const pm = detectPackageManager(cwd);
+
+  // Next.js
+  if (has('next')) {
+    const outputDir = fs.existsSync(path.join(cwd, 'out')) ? 'out' :
+                      fs.existsSync(path.join(cwd, '.next')) ? '.next' : 'out';
+    return {
+      framework: 'nextjs',
+      buildCommand: `${pm} run build`,
+      outputDir,
+      isServer: false,
+      packageManager: pm,
+      confidence: 99,
+    };
+  }
+
+  // SvelteKit
+  if (has('@sveltejs/kit')) {
+    return {
+      framework: 'sveltekit',
+      buildCommand: `${pm} run build`,
+      outputDir: 'build',
+      isServer: false,
+      packageManager: pm,
+      confidence: 95,
+    };
+  }
+
+  // Astro
+  if (has('astro')) {
+    return {
+      framework: 'astro',
+      buildCommand: `${pm} run build`,
+      outputDir: 'dist',
+      isServer: false,
+      packageManager: pm,
+      confidence: 95,
+    };
+  }
+
+  // Remix
+  if (has('@remix-run/react') || has('@remix-run/node')) {
+    return {
+      framework: 'remix',
+      buildCommand: `${pm} run build`,
+      outputDir: 'public',
+      isServer: true,
+      packageManager: pm,
+      confidence: 90,
+    };
+  }
+
+  // Nuxt
+  if (has('nuxt') || has('nuxt3') || has('nuxt-edge')) {
+    return {
+      framework: 'nuxt',
+      buildCommand: `${pm} run generate`,
+      outputDir: '.output/public',
+      isServer: false,
+      packageManager: pm,
+      confidence: 90,
+    };
+  }
+
+  // Vite (React/Vue/Svelte/Solid)
+  if (has('vite')) {
+    const outputDir = 'dist';
+    if (has('react') || has('react-dom')) {
+      return { framework: 'react-cra', buildCommand: `${pm} run build`, outputDir, isServer: false, packageManager: pm, confidence: 88 };
+    }
+    if (has('vue')) {
+      return { framework: 'vue', buildCommand: `${pm} run build`, outputDir, isServer: false, packageManager: pm, confidence: 88 };
+    }
+    if (has('svelte')) {
+      return { framework: 'svelte', buildCommand: `${pm} run build`, outputDir, isServer: false, packageManager: pm, confidence: 88 };
+    }
+    if (has('solid-js')) {
+      return { framework: 'solid', buildCommand: `${pm} run build`, outputDir, isServer: false, packageManager: pm, confidence: 88 };
+    }
+    return { framework: 'vite', buildCommand: `${pm} run build`, outputDir, isServer: false, packageManager: pm, confidence: 85 };
+  }
+
+  // Express/Fastify/Hono server
+  if (has('express')) {
+    return { framework: 'express', buildCommand: null, outputDir: '.', isServer: true, port: 3000, packageManager: pm, confidence: 80 };
+  }
+  if (has('fastify')) {
+    return { framework: 'fastify', buildCommand: null, outputDir: '.', isServer: true, port: 3000, packageManager: pm, confidence: 80 };
+  }
+  if (has('hono')) {
+    return { framework: 'hono', buildCommand: null, outputDir: '.', isServer: true, port: 3000, packageManager: pm, confidence: 80 };
+  }
+
+  // Static HTML/dist/build
+  if (hasFile('index.html') || hasFile('dist/index.html') || hasFile('build/index.html') || hasFile('out/index.html')) {
+    const outputDir = fs.existsSync(path.join(cwd, 'dist/index.html')) ? 'dist' :
+                      fs.existsSync(path.join(cwd, 'build/index.html')) ? 'build' :
+                      fs.existsSync(path.join(cwd, 'out/index.html')) ? 'out' : '.';
+    return { framework: 'static', buildCommand: null, outputDir, isServer: false, packageManager: pm, confidence: 70 };
+  }
+
+  return { framework: 'unknown', buildCommand: null, outputDir: '.', isServer: false, packageManager: pm, confidence: 10 };
+}
+
+function detectPackageManager(cwd: string): 'npm' | 'pnpm' | 'yarn' | 'bun' {
+  if (fs.existsSync(path.join(cwd, 'bun.lockb'))) return 'bun';
+  if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (fs.existsSync(path.join(cwd, 'yarn.lock'))) return 'yarn';
+  return 'npm';
+}
+
+function readJson(filePath: string): any {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}

package/src/core/qr.ts

@@ -0,0 +1,30 @@
+import qrcode from 'qrcode-terminal';
+import chalk from 'chalk';
+import { theme } from '../ui/theme.js';
+
+export async function showQR(url: string): Promise<void> {
+  console.log('');
+  console.log(theme.muted('  ┌─────────────────────────────────┐'));
+  console.log(theme.muted('  │') + '   ' + theme.accent('Scan to open on mobile') + '          ' + theme.muted('│'));
+  console.log(theme.muted('  └─────────────────────────────────┘'));
+  console.log('');
+  qrcode.generate(url, { small: true });
+  console.log('');
+}
+
+export async function copyToClipboard(text: string): Promise<boolean> {
+  try {
+    const { default: clipboardy } = await import('clipboardy');
+    await clipboardy.write(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function openBrowser(url: string): Promise<void> {
+  try {
+    const { default: open } = await import('open');
+    await open(url);
+  } catch {}
+}

package/src/core/tunnel.ts

@@ -0,0 +1,70 @@
+import WebSocket from 'ws';
+import chokidar from 'chokidar';
+import path from 'path';
+import chalk from 'chalk';
+import { theme } from '../ui/theme.js';
+
+export interface LiveSyncOptions {
+  watchDir: string;
+  slug: string;
+  liveToken: string;
+  wsBase?: string;
+  onUpdate?: () => Promise<void>;
+}
+
+export function startLiveSync(opts: LiveSyncOptions): () => void {
+  const wsUrl = opts.wsBase || 'wss://live.nivii.app';
+  let ws: WebSocket | null = null;
+  let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+
+  function connect() {
+    ws = new WebSocket(`${wsUrl}/live/${opts.slug}?token=${opts.liveToken}`);
+
+    ws.on('open', () => {
+      console.log(theme.success('  ⚡') + ' ' + chalk.white('Live sync connected'));
+    });
+
+    ws.on('close', () => {
+      console.log(theme.muted('  ↻  Live sync reconnecting…'));
+      reconnectTimer = setTimeout(connect, 3000);
+    });
+
+    ws.on('error', () => {
+      // silent
+    });
+  }
+
+  connect();
+
+  // Watch for file changes
+  const watcher = chokidar.watch(opts.watchDir, {
+    ignored: /(^|[/\\])\..|(node_modules)/,
+    persistent: true,
+    ignoreInitial: true,
+  });
+
+  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+  const triggerUpdate = (filePath: string) => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+      console.log('');
+      console.log(theme.accent('  ⚡') + ' ' + chalk.white('Change detected: ') + chalk.hex('#6B7280')(path.relative(opts.watchDir, filePath)));
+      if (opts.onUpdate) {
+        await opts.onUpdate();
+      }
+      if (ws?.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'reload', slug: opts.slug }));
+      }
+    }, 300);
+  };
+
+  watcher.on('change', triggerUpdate);
+  watcher.on('add', triggerUpdate);
+  watcher.on('unlink', triggerUpdate);
+
+  return () => {
+    watcher.close();
+    if (reconnectTimer) clearTimeout(reconnectTimer);
+    ws?.close();
+  };
+}

package/src/core/upload.ts

@@ -0,0 +1,95 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import fetch from 'node-fetch';
+import FormData from 'form-data';
+import { createSpinner } from '../ui/spinner.js';
+import { API_BASE } from '../utils/config.js';
+import chalk from 'chalk';
+
+export interface UploadOptions {
+  buildDir: string;      // path to the built output directory
+  slug: string;
+  token?: string;
+  password?: string;
+  otp?: boolean;
+  expires?: string;
+  live?: boolean;
+  collab?: boolean;
+  maxViews?: number;
+  selfDestruct?: boolean;
+}
+
+export interface DeployResult {
+  url: string;
+  slug: string;
+  liveToken?: string;
+  collabToken?: string;
+  otpCode?: string;
+  expiresAt?: string;
+}
+
+/** Recursively collect all files under a directory */
+function collectFiles(dir: string, base: string = dir): { abs: string; rel: string }[] {
+  const results: { abs: string; rel: string }[] = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const abs = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectFiles(abs, base));
+    } else {
+      results.push({ abs, rel: path.relative(base, abs).replace(/\\/g, '/') });
+    }
+  }
+  return results;
+}
+
+export async function uploadDeploy(opts: UploadOptions): Promise<DeployResult> {
+  const spinner = createSpinner('Uploading to edge network…');
+  spinner.start();
+
+  try {
+    const files = collectFiles(opts.buildDir);
+
+    if (files.length === 0) {
+      throw new Error('No files found in build directory');
+    }
+
+    const form = new FormData();
+    form.append('slug', opts.slug);
+    form.append('fileCount', String(files.length));
+    if (opts.password)    form.append('password', opts.password);
+    if (opts.otp)         form.append('otp', 'true');
+    if (opts.expires)     form.append('expires', opts.expires);
+    if (opts.live)        form.append('live', 'true');
+    if (opts.collab)      form.append('collab', 'true');
+    if (opts.maxViews)    form.append('maxViews', String(opts.maxViews));
+    if (opts.selfDestruct) form.append('selfDestruct', 'true');
+
+    // Attach each file with its relative path as the field name
+    for (const { abs, rel } of files) {
+      form.append('file[]', fs.createReadStream(abs), { filename: rel });
+      form.append('path[]', rel);
+    }
+
+    const res = await fetch(`${API_BASE}/deploy`, {
+      method: 'POST',
+      headers: {
+        ...(opts.token ? { Authorization: `Bearer ${opts.token}` } : {}),
+        ...form.getHeaders(),
+      },
+      body: form,
+    });
+
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Upload failed: ${res.status} ${body}`);
+    }
+
+    const result = await res.json() as DeployResult;
+    spinner.succeed(chalk.hex('#10B981')('Deployed to edge ') + chalk.hex('#6B7280')(`(${opts.slug})`));
+    return result;
+  } catch (err: any) {
+    spinner.fail(chalk.hex('#EF4444')('Upload failed'));
+    throw err;
+  }
+}

package/src/ui/spinner.ts

@@ -0,0 +1,36 @@
+import ora, { Ora } from 'ora';
+import chalk from 'chalk';
+
+const FRAMES = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
+
+export function createSpinner(text: string): Ora {
+  return ora({
+    text: chalk.hex('#A78BFA')(text),
+    spinner: {
+      interval: 80,
+      frames: FRAMES.map(f => chalk.hex('#7C3AED')(f)),
+    },
+    color: 'magenta',
+  });
+}
+
+export function step(emoji: string, text: string, detail?: string) {
+  const msg = chalk.hex('#A78BFA')(emoji + '  ' + chalk.white(text));
+  if (detail) {
+    console.log(msg + '  ' + chalk.hex('#6B7280')(detail));
+  } else {
+    console.log(msg);
+  }
+}
+
+export function success(text: string) {
+  console.log(chalk.hex('#10B981')('  ✓  ') + chalk.white(text));
+}
+
+export function warn(text: string) {
+  console.log(chalk.hex('#F59E0B')('  ⚠  ') + chalk.white(text));
+}
+
+export function error(text: string) {
+  console.log(chalk.hex('#EF4444')('  ✗  ') + chalk.white(text));
+}

package/src/ui/theme.ts

@@ -0,0 +1,35 @@
+import chalk from 'chalk';
+
+export const theme = {
+  primary: chalk.hex('#7C3AED'),     // violet
+  accent: chalk.hex('#06B6D4'),      // cyan
+  success: chalk.hex('#10B981'),     // emerald
+  warning: chalk.hex('#F59E0B'),     // amber
+  error: chalk.hex('#EF4444'),       // red
+  muted: chalk.hex('#6B7280'),       // gray
+  white: chalk.white,
+  bold: chalk.bold,
+  dim: chalk.dim,
+
+  gradient: (text: string) => {
+    const chars = text.split('');
+    const colors = ['#7C3AED', '#8B5CF6', '#A78BFA', '#06B6D4', '#22D3EE'];
+    return chars.map((c, i) => chalk.hex(colors[i % colors.length])(c)).join('');
+  },
+
+  box: (lines: string[]) => {
+    const maxLen = Math.max(...lines.map(l => stripAnsi(l).length));
+    const border = chalk.hex('#7C3AED')('─'.repeat(maxLen + 4));
+    const top = chalk.hex('#7C3AED')('╭') + border + chalk.hex('#7C3AED')('╮');
+    const bottom = chalk.hex('#7C3AED')('╰') + border + chalk.hex('#7C3AED')('╯');
+    const mid = lines.map(l => {
+      const pad = maxLen - stripAnsi(l).length;
+      return chalk.hex('#7C3AED')('│') + '  ' + l + ' '.repeat(pad) + '  ' + chalk.hex('#7C3AED')('│');
+    });
+    return [top, ...mid, bottom].join('\n');
+  }
+};
+
+function stripAnsi(str: string): string {
+  return str.replace(/\x1b\[[0-9;]*m/g, '');
+}

package/src/ui/welcome.ts

@@ -0,0 +1,104 @@
+import chalk from 'chalk';
+
+// Fixed NIVII ASCII art — V now properly narrows to a point
+const NIVII_ASCII = [
+  '███╗   ██╗██╗██╗   ██╗██╗██╗',
+  '████╗  ██║██║██║   ██║██║██║',
+  '██╔██╗ ██║██║██║   ██║██║██║',
+  '██║╚██╗██║██║╚██╗ ██╔╝██║██║',
+  '██║ ╚████║██║ ╚████╔╝ ██║██║',
+  '╚═╝  ╚═══╝╚═╝  ╚═══╝  ╚═╝╚═╝',
+];
+
+const GRADIENT = [
+  '#6B21A8',
+  '#7C3AED',
+  '#8B5CF6',
+  '#A78BFA',
+  '#C4B5FD',
+  '#DDD6FE',
+];
+
+const cyan   = chalk.hex('#06B6D4');
+const gray   = chalk.hex('#6B7280');
+const green  = chalk.hex('#10B981');
+const orange = chalk.hex('#F97316');
+const white  = chalk.white;
+const purple = chalk.hex('#A78BFA');
+
+// Snow/sparkle effect row
+const SNOW_CHARS = ['✦', '✧', '⋆', '·', '❄', '❆', '✵', '˚', '*', ' ', ' ', ' ', ' ', ' '];
+function snowRow(width: number, color: string): string {
+  return Array.from({ length: width }, () => {
+    const ch = SNOW_CHARS[Math.floor(Math.random() * SNOW_CHARS.length)];
+    return chalk.hex(color)(ch);
+  }).join('');
+}
+
+function printSnow(): void {
+  // Two rows of snow — alternating purple shades
+  console.log('  ' + snowRow(30, '#7C3AED'));
+  console.log('  ' + snowRow(30, '#A78BFA'));
+}
+
+export function showWelcome(): void {
+  console.log('');
+  printSnow();
+  for (let i = 0; i < NIVII_ASCII.length; i++) {
+    console.log('  ' + chalk.hex(GRADIENT[i])(NIVII_ASCII[i]));
+  }
+  printSnow();
+  console.log('');
+  console.log('  ' + orange('⚡') + ' ' + cyan('Share any project in seconds. No accounts. No config.'));
+  console.log('  ' + gray('v0.1.8 · nivii.app'));
+  console.log('');
+  console.log('  ' + gray('─'.repeat(46)));
+  console.log('  ' + cyan('Quick start:') + '  ' + white('nivii share'));
+  console.log('  ' + cyan('Custom slug:') + '  ' + white('nivii share --slug my-demo'));
+  console.log('  ' + cyan('With password:') + white('nivii share --pass secret123'));
+  console.log('  ' + cyan('Live sync:') + '    ' + white('nivii share --live'));
+  console.log('  ' + gray('─'.repeat(46)));
+  console.log('');
+  console.log('  ' + green('✓') + ' ' + cyan('First-run setup complete!') + gray(' Config saved to ~/.nivii/config.json'));
+  console.log('');
+}
+
+export function showHelp(): void {
+  console.log('');
+  printSnow();
+  for (let i = 0; i < NIVII_ASCII.length; i++) {
+    console.log('  ' + chalk.hex(GRADIENT[i])(NIVII_ASCII[i]));
+  }
+  printSnow();
+  console.log('');
+  console.log('  ' + orange('⚡') + ' ' + cyan('Share any project in seconds. No accounts. No config.'));
+  console.log('  ' + gray('v0.1.8 · nivii.app'));
+  console.log('');
+  console.log('  ' + gray('─'.repeat(50)));
+  console.log('  ' + purple.bold('Commands'));
+  console.log('');
+  console.log('  ' + cyan('nivii share') + '                     ' + gray('Deploy current directory'));
+  console.log('  ' + cyan('nivii share --slug my-demo') + '      ' + gray('Custom slug (Pro)'));
+  console.log('  ' + cyan('nivii share --pass secret') + '       ' + gray('Password protect'));
+  console.log('  ' + cyan('nivii share --expires 24h') + '       ' + gray('Set expiry (1h/24h/7d/30d)'));
+  console.log('  ' + cyan('nivii share --live') + '              ' + gray('Live sync on file changes'));
+  console.log('  ' + cyan('nivii share --no-build') + '          ' + gray('Skip build step'));
+  console.log('  ' + cyan('nivii ls') + '                        ' + gray('List recent deployments'));
+  console.log('  ' + cyan('nivii whoami') + '                    ' + gray('Show account info'));
+  console.log('  ' + cyan('nivii analytics [slug]') + '          ' + gray('View deployment analytics'));
+  console.log('  ' + cyan('nivii config') + '                    ' + gray('View/set config values'));
+  console.log('');
+  console.log('  ' + gray('─'.repeat(50)));
+  console.log('  ' + gray('Docs: ') + white('https://nivii.app') + '  ' + gray('·') + '  ' + gray('Pro: ') + white('https://nivii.app/#pricing'));
+  console.log('');
+}
+
+export function showBanner(): void {
+  console.log('');
+  console.log(
+    '  ' + orange('⚡') + '   ' +
+    chalk.hex('#A78BFA').bold('NIVII') + '   ' +
+    gray('v0.1.8')
+  );
+  console.log('');
+}

package/src/utils/config.ts

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export interface NiviiConfig {
+  token?: string;
+  plan?: 'free' | 'pro';
+  apiBase?: string;
+  firstRun?: boolean;
+  deployments?: Array<{
+    slug: string;
+    url: string;
+    createdAt: string;
+    expiresAt?: string;
+  }>;
+}
+
+const CONFIG_DIR = path.join(os.homedir(), '.nivii');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+export const API_BASE = process.env.NIVII_API || 'https://api.nivii.app';
+
+export function loadConfig(): NiviiConfig {
+  try {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    if (!fs.existsSync(CONFIG_FILE)) {
+      const defaults: NiviiConfig = { firstRun: true, apiBase: API_BASE, deployments: [] };
+      saveConfig(defaults);
+      return defaults;
+    }
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+  } catch {
+    return { firstRun: true, apiBase: API_BASE, deployments: [] };
+  }
+}
+
+export function saveConfig(config: NiviiConfig): void {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export function updateConfig(updates: Partial<NiviiConfig>): NiviiConfig {
+  const current = loadConfig();
+  const updated = { ...current, ...updates };
+  saveConfig(updated);
+  return updated;
+}

package/src/utils/hash.ts

@@ -0,0 +1,11 @@
+import crypto from 'crypto';
+
+export function generateSlug(length = 8): string {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+  const bytes = crypto.randomBytes(length);
+  return Array.from(bytes).map(b => chars[b % chars.length]).join('');
+}
+
+export function hashFile(content: Buffer): string {
+  return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}

package/src/utils/zip.ts

@@ -0,0 +1,22 @@
+import fs from 'fs';
+import path from 'path';
+import { createWriteStream } from 'fs';
+import archiver from 'archiver';
+import os from 'os';
+
+export async function zipDirectory(sourceDir: string): Promise<string> {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nivii-'));
+  const zipPath = path.join(tmpDir, 'deploy.zip');
+
+  return new Promise((resolve, reject) => {
+    const output = createWriteStream(zipPath);
+    const archive = archiver('zip', { zlib: { level: 9 } });
+
+    output.on('close', () => resolve(zipPath));
+    archive.on('error', reject);
+
+    archive.pipe(output);
+    archive.directory(sourceDir, false);
+    archive.finalize();
+  });
+}