supaslidev 0.1.4 → 0.2.0

package/server/api/presentations/upload.post.ts

@@ -0,0 +1,174 @@
+import { spawn } from 'node:child_process';
+import { join, dirname, normalize, resolve, sep } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import {
+  SLUG_REGEX,
+  shouldIgnore,
+  convertToCatalogDependencies,
+  hasSharedPackage,
+  addSharedDependencyToPackageJson,
+  addSharedAddonToSlides,
+  regeneratePresentationsJson,
+} from '../../../src/shared/index.js';
+import { getProjectRoot, getPresentationsDir, getPresentationsJsonPath } from '../../utils/config';
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const { files, name, folderName } = body;
+
+  if (!Array.isArray(files) || files.length === 0) {
+    throw createError({
+      statusCode: 400,
+      data: { field: 'files', message: 'No files provided' },
+    });
+  }
+
+  const hasSlides = files.some((f: { path: string }) => f.path === 'slides.md');
+  const hasPackageJson = files.some((f: { path: string }) => f.path === 'package.json');
+
+  if (!hasSlides) {
+    throw createError({
+      statusCode: 400,
+      data: { field: 'files', message: 'No slides.md found in uploaded files' },
+    });
+  }
+
+  if (!hasPackageJson) {
+    throw createError({
+      statusCode: 400,
+      data: { field: 'files', message: 'No package.json found in uploaded files' },
+    });
+  }
+
+  const projectRoot = getProjectRoot();
+  const presentationsDir = getPresentationsDir();
+
+  const presentationName =
+    name ||
+    (folderName || 'presentation')
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .replace(/-{2,}/g, '-')
+      .replace(/^-+|-+$/g, '')
+    || 'presentation';
+
+  if (!SLUG_REGEX.test(presentationName)) {
+    throw createError({
+      statusCode: 400,
+      data: {
+        field: 'name',
+        message: 'Name must be a valid slug (lowercase letters, numbers, hyphens only)',
+      },
+    });
+  }
+
+  const destinationPath = join(presentationsDir, presentationName);
+
+  if (existsSync(destinationPath)) {
+    throw createError({
+      statusCode: 400,
+      data: { field: 'name', message: 'A presentation with this name already exists' },
+    });
+  }
+
+  mkdirSync(destinationPath, { recursive: true });
+
+  const resolvedDest = resolve(destinationPath);
+  for (const file of files) {
+    if (shouldIgnore(file.path.split('/')[0])) {
+      continue;
+    }
+
+    const normalizedPath = normalize(file.path).replace(/^(\.\.[\\/])+/, '');
+    if (normalizedPath.includes('..') || normalizedPath.startsWith('/') || normalizedPath.includes('\0')) {
+      continue;
+    }
+    const filePath = resolve(destinationPath, normalizedPath);
+    if (!filePath.startsWith(resolvedDest + sep) && filePath !== resolvedDest) {
+      continue;
+    }
+    const fileDir = dirname(filePath);
+
+    if (!existsSync(fileDir)) {
+      mkdirSync(fileDir, { recursive: true });
+    }
+
+    if (file.encoding === 'base64') {
+      writeFileSync(filePath, Buffer.from(file.content, 'base64'));
+    } else {
+      writeFileSync(filePath, file.content, 'utf-8');
+    }
+  }
+
+  const packageJsonPath = join(destinationPath, 'package.json');
+  let packageJson: Record<string, unknown>;
+  try {
+    const packageJsonContent = readFileSync(packageJsonPath, 'utf-8');
+    packageJson = JSON.parse(packageJsonContent);
+  } catch {
+    throw createError({
+      statusCode: 400,
+      data: { field: 'files', message: 'Malformed package.json in uploaded files' },
+    });
+  }
+
+  packageJson.name = `@supaslidev/${presentationName}`;
+  packageJson.private = true;
+  packageJson.scripts = {
+    dev: 'slidev --open',
+    build: 'slidev build',
+    export: 'slidev export',
+  };
+
+  if (packageJson.dependencies) {
+    packageJson.dependencies = convertToCatalogDependencies(packageJson.dependencies);
+  }
+  if (packageJson.devDependencies) {
+    packageJson.devDependencies = convertToCatalogDependencies(packageJson.devDependencies);
+  }
+
+  const sharedExists = hasSharedPackage(projectRoot);
+  if (sharedExists) {
+    addSharedDependencyToPackageJson(packageJson);
+  }
+
+  writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+
+  if (sharedExists) {
+    const slidesPath = join(destinationPath, 'slides.md');
+    if (existsSync(slidesPath)) {
+      addSharedAddonToSlides(slidesPath);
+    }
+  }
+
+  regeneratePresentationsJson(presentationsDir, getPresentationsJsonPath());
+
+  const presentation = {
+    id: presentationName,
+    title: presentationName,
+    description: '',
+    theme: 'default',
+    background: 'https://cover.sli.dev',
+    duration: '',
+  };
+
+  // Run pnpm install in background
+  const install = spawn('pnpm', ['install'], {
+    cwd: projectRoot,
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  install.on('close', (code: number | null) => {
+    if (code !== 0) {
+      console.error(`[upload] pnpm install failed with code ${code}`);
+    }
+  });
+
+  install.on('error', (err) => {
+    console.error(`[upload] pnpm install spawn error: ${err.message}`);
+  });
+
+  setResponseStatus(event, 201);
+  return presentation;
+});

package/server/api/presentations/validate.post.ts

@@ -0,0 +1,14 @@
+import { validatePaths } from '../../../src/shared/index.js';
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+
+  if (!body || !Array.isArray(body.paths)) {
+    throw createError({
+      statusCode: 400,
+      data: { message: 'paths must be an array' },
+    });
+  }
+
+  return validatePaths(body.paths);
+});

package/server/api/servers/[id].delete.ts

@@ -0,0 +1,15 @@
+import { stopPresentationServer } from '../../utils/process-manager';
+
+export default defineEventHandler((event) => {
+  const id = getRouterParam(event, 'id');
+  if (!id) {
+    throw createError({ statusCode: 400, data: { message: 'Missing server id' } });
+  }
+  const result = stopPresentationServer(id);
+
+  if (!result.success) {
+    throw createError({ statusCode: 404, data: result });
+  }
+
+  return result;
+});

package/server/api/servers/[id].post.ts

@@ -0,0 +1,17 @@
+import { startPresentationServer } from '../../utils/process-manager';
+import { getProjectRoot } from '../../utils/config';
+
+export default defineEventHandler((event) => {
+  const id = getRouterParam(event, 'id');
+  if (!id) {
+    throw createError({ statusCode: 400, data: { message: 'Missing server id' } });
+  }
+  const projectRoot = getProjectRoot();
+  const result = startPresentationServer(id, projectRoot);
+
+  if (!result.success) {
+    throw createError({ statusCode: 500, data: result });
+  }
+
+  return result;
+});

package/server/api/servers/index.delete.ts

@@ -0,0 +1,5 @@
+import { stopAllPresentationServers } from '../../utils/process-manager';
+
+export default defineEventHandler(() => {
+  return stopAllPresentationServers();
+});

package/server/api/servers/index.get.ts

@@ -0,0 +1,5 @@
+import { getServersStatus } from '../../utils/process-manager';
+
+export default defineEventHandler(() => {
+  return getServersStatus();
+});

package/server/api/servers/stop-all.post.ts

@@ -0,0 +1,5 @@
+import { stopAllPresentationServers } from '../../utils/process-manager';
+
+export default defineEventHandler(() => {
+  return stopAllPresentationServers();
+});

package/server/plugins/generate.ts

@@ -0,0 +1,12 @@
+import { regeneratePresentationsJson } from '../../src/shared/presentations.js';
+import { getPresentationsDir, getPresentationsJsonPath } from '../utils/config';
+
+export default defineNitroPlugin(() => {
+  const presentationsDir = getPresentationsDir();
+  const presentationsJsonPath = getPresentationsJsonPath();
+
+  console.log(`[generate] presentationsDir: ${presentationsDir}`);
+  console.log(`[generate] presentationsJsonPath: ${presentationsJsonPath}`);
+
+  regeneratePresentationsJson(presentationsDir, presentationsJsonPath);
+});

package/server/plugins/shutdown.ts

@@ -0,0 +1,16 @@
+import { stopAllPresentationServers } from '../utils/process-manager';
+
+export default defineNitroPlugin((nitroApp) => {
+  const cleanup = () => {
+    console.log('\nShutting down servers...');
+    stopAllPresentationServers();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+
+  nitroApp.hooks.hook('close', () => {
+    stopAllPresentationServers();
+  });
+});

package/server/routes/exports/[...path].get.ts

@@ -0,0 +1,25 @@
+import { join, basename, relative } from 'node:path';
+import { existsSync, createReadStream } from 'node:fs';
+import { getProjectRoot } from '../../utils/config';
+
+export default defineEventHandler((event) => {
+  const path = getRouterParam(event, 'path') || '';
+  const projectRoot = getProjectRoot();
+  const exportsDir = join(projectRoot, 'exports');
+  const filePath = join(exportsDir, path);
+
+  const rel = relative(exportsDir, filePath);
+  if (
+    rel.startsWith('..') ||
+    !filePath.startsWith(exportsDir) ||
+    !existsSync(filePath) ||
+    !filePath.endsWith('.pdf')
+  ) {
+    throw createError({ statusCode: 404, message: 'Not found' });
+  }
+
+  setHeader(event, 'Content-Type', 'application/pdf');
+  setHeader(event, 'Content-Disposition', `inline; filename="${basename(filePath)}"`);
+
+  return sendStream(event, createReadStream(filePath));
+});

package/server/utils/config.ts

@@ -0,0 +1,13 @@
+import { join } from 'node:path';
+
+export function getProjectRoot(): string {
+  return process.env.SUPASLIDEV_PROJECT_ROOT || join(process.cwd());
+}
+
+export function getPresentationsDir(): string {
+  return process.env.SUPASLIDEV_PRESENTATIONS_DIR || join(getProjectRoot(), 'presentations');
+}
+
+export function getPresentationsJsonPath(): string {
+  return join(getProjectRoot(), '.supaslidev', 'presentations.json');
+}

package/server/utils/process-manager.ts

@@ -0,0 +1,119 @@
+import { spawn, execSync, type ChildProcess } from 'node:child_process';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { isValidPresentationId } from '../../src/shared/validation.js';
+
+const IS_WINDOWS = process.platform === 'win32';
+
+interface ServerEntry {
+  process: ChildProcess;
+  port: number;
+}
+
+const runningServers = new Map<string, ServerEntry>();
+
+export function getNextPort(): number {
+  const usedPorts = new Set([...runningServers.values()].map((s) => s.port));
+  let port = 3030;
+  while (usedPorts.has(port)) {
+    port++;
+  }
+  return port;
+}
+
+export function startPresentationServer(
+  presentationId: string,
+  projectRoot: string,
+): { success: boolean; port?: number; error?: string; alreadyRunning?: boolean } {
+  if (!isValidPresentationId(presentationId)) {
+    return { success: false, error: 'Invalid presentation id' };
+  }
+
+  if (runningServers.has(presentationId)) {
+    return { success: true, port: runningServers.get(presentationId)!.port, alreadyRunning: true };
+  }
+
+  const presentationPath = join(projectRoot, 'presentations', presentationId);
+  const slidevBin = join(presentationPath, 'node_modules', '.bin', 'slidev');
+
+  if (!existsSync(presentationPath)) {
+    return { success: false, error: 'Presentation not found' };
+  }
+
+  if (!existsSync(slidevBin)) {
+    return { success: false, error: 'Dependencies not installed. Run pnpm install first.' };
+  }
+
+  const port = getNextPort();
+
+  const child = spawn(slidevBin, ['--port', String(port), '--open', 'false'], {
+    cwd: presentationPath,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    detached: !IS_WINDOWS,
+    shell: IS_WINDOWS,
+  });
+
+  child.unref();
+
+  runningServers.set(presentationId, { process: child, port });
+
+  child.stderr?.on('data', (data: Buffer) => {
+    console.error(`[${presentationId}] stderr:`, data.toString());
+  });
+
+  child.on('close', (code: number | null) => {
+    console.log(`[${presentationId}] process exited with code ${code}`);
+    runningServers.delete(presentationId);
+  });
+
+  child.on('error', (err: Error) => {
+    console.error(`Failed to start server for ${presentationId}:`, err);
+    runningServers.delete(presentationId);
+  });
+
+  return { success: true, port, alreadyRunning: false };
+}
+
+export function stopPresentationServer(presentationId: string): {
+  success: boolean;
+  error?: string;
+} {
+  const server = runningServers.get(presentationId);
+  if (!server) {
+    return { success: false, error: 'Server not running' };
+  }
+
+  if (IS_WINDOWS) {
+    try {
+      execSync(`taskkill /pid ${server.process.pid} /T /F`, { stdio: 'ignore' });
+    } catch {
+      // Process may have already exited
+    }
+  } else {
+    server.process.kill('SIGTERM');
+  }
+  runningServers.delete(presentationId);
+  return { success: true };
+}
+
+export function stopAllPresentationServers(): {
+  success: boolean;
+  stopped: string[];
+} {
+  const stopped: string[] = [];
+  for (const [id] of runningServers) {
+    const result = stopPresentationServer(id);
+    if (result.success) {
+      stopped.push(id);
+    }
+  }
+  return { success: true, stopped };
+}
+
+export function getServersStatus(): Record<string, { port: number }> {
+  const servers: Record<string, { port: number }> = {};
+  for (const [id, server] of runningServers) {
+    servers[id] = { port: server.port };
+  }
+  return servers;
+}

package/src/cli/commands/create.ts

@@ -0,0 +1,125 @@
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs';
+import { findProjectRoot } from '../utils.js';
+import {
+  validateName,
+  hasSharedPackage,
+  addSharedAddonToSlides,
+  addSharedDependencyToPackageJson,
+} from '../../shared/index.js';
+
+function checkDuplicateName(presentationsDir: string, name: string): void {
+  const presentationPath = join(presentationsDir, name);
+  if (existsSync(presentationPath)) {
+    throw new Error(`Presentation "${name}" already exists`);
+  }
+}
+
+function getExistingPresentations(presentationsDir: string): Set<string> {
+  if (!existsSync(presentationsDir)) return new Set();
+  return new Set(
+    readdirSync(presentationsDir).filter((name) => {
+      const fullPath = join(presentationsDir, name);
+      return statSync(fullPath).isDirectory();
+    }),
+  );
+}
+
+function configureSharedPackage(projectRoot: string, presentationDir: string): void {
+  if (!hasSharedPackage(projectRoot)) return;
+
+  const slidesPath = join(presentationDir, 'slides.md');
+  const packageJsonPath = join(presentationDir, 'package.json');
+
+  if (existsSync(slidesPath)) {
+    addSharedAddonToSlides(slidesPath);
+  }
+
+  if (existsSync(packageJsonPath)) {
+    const content = readFileSync(packageJsonPath, 'utf-8');
+    const packageJson = JSON.parse(content);
+    addSharedDependencyToPackageJson(packageJson);
+    writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+  }
+}
+
+export async function create(name?: string): Promise<void> {
+  const projectRoot = findProjectRoot();
+
+  if (!projectRoot) {
+    console.error('Error: Could not find a Supaslidev project.');
+    console.error('Make sure you are in a directory with a "presentations" folder.');
+    process.exit(1);
+  }
+
+  const presentationsDir = join(projectRoot, 'presentations');
+
+  if (!existsSync(presentationsDir)) {
+    console.error(`Error: No "presentations" folder found at ${presentationsDir}`);
+    process.exit(1);
+  }
+
+  if (name) {
+    try {
+      validateName(name);
+      checkDuplicateName(presentationsDir, name);
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : 'Invalid name'}`);
+      process.exit(1);
+    }
+  }
+
+  const existingPresentations = getExistingPresentations(presentationsDir);
+
+  const args = ['create', 'slidev'];
+  if (name) {
+    args.push(name);
+  }
+
+  console.log(`Creating new presentation in: ${presentationsDir}`);
+
+  return new Promise((resolve, reject) => {
+    const child = spawn('pnpm', args, {
+      cwd: presentationsDir,
+      stdio: 'inherit',
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        console.error(`Failed to create presentation (exit code: ${code})`);
+        reject(new Error(`Process exited with code ${code}`));
+        return;
+      }
+
+      const presentationName = name ?? findNewPresentation(presentationsDir, existingPresentations);
+
+      if (presentationName) {
+        const presentationDir = join(presentationsDir, presentationName);
+        configureSharedPackage(projectRoot, presentationDir);
+      }
+
+      console.log('\nPresentation created successfully!');
+      console.log('Run "supaslidev present <name>" to start a dev server for your presentation.');
+      resolve();
+    });
+
+    child.on('error', (err) => {
+      console.error('Failed to create presentation:', err.message);
+      reject(err);
+    });
+  });
+}
+
+function findNewPresentation(
+  presentationsDir: string,
+  existingPresentations: Set<string>,
+): string | null {
+  const currentPresentations = getExistingPresentations(presentationsDir);
+  for (const name of currentPresentations) {
+    if (!existingPresentations.has(name)) {
+      return name;
+    }
+  }
+  return null;
+}

package/src/cli/commands/deploy.ts

@@ -0,0 +1,90 @@
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { existsSync, mkdirSync, cpSync, rmSync, writeFileSync } from 'node:fs';
+import {
+  findProjectRoot,
+  getPresentations,
+  printAvailablePresentations,
+  createVercelConfig,
+  createNetlifyConfig,
+  createDeployPackageJson,
+} from '../utils.js';
+
+export interface DeployOptions {
+  output?: string;
+}
+
+export async function deploy(name: string, options: DeployOptions = {}): Promise<void> {
+  const projectRoot = findProjectRoot();
+
+  if (!projectRoot) {
+    console.error('Error: Could not find a Supaslidev project.');
+    console.error('Make sure you are in a directory with a "presentations" folder.');
+    process.exit(1);
+  }
+
+  const presentationsDir = join(projectRoot, 'presentations');
+  const deployDir = join(projectRoot, 'deploy');
+  const presentations = getPresentations(presentationsDir);
+
+  if (!presentations.includes(name)) {
+    console.error(`Error: Presentation "${name}" not found`);
+    printAvailablePresentations(presentations);
+    process.exit(1);
+  }
+
+  const presentationDir = join(presentationsDir, name);
+  const presentationDistDir = join(presentationDir, 'dist');
+  const outputDir = options.output ?? join(deployDir, name);
+  const outputDistDir = join(outputDir, 'dist');
+
+  console.log('\n' + '='.repeat(50));
+  console.log(`  Preparing deployment: ${name}`);
+  console.log('='.repeat(50) + '\n');
+
+  console.log('Step 1/3: Building presentation...');
+
+  const slidev = spawn('npx', ['slidev', 'build'], {
+    cwd: presentationDir,
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  slidev.on('error', (err) => {
+    console.error(`Failed to build presentation: ${err.message}`);
+    process.exit(1);
+  });
+
+  slidev.on('close', (code) => {
+    if (code !== 0) {
+      console.error(`\nBuild failed with exit code ${code}`);
+      process.exit(code ?? 1);
+    }
+
+    console.log('\nStep 2/3: Creating deploy package...');
+
+    if (existsSync(outputDir)) {
+      rmSync(outputDir, { recursive: true });
+    }
+    mkdirSync(outputDir, { recursive: true });
+
+    cpSync(presentationDistDir, outputDistDir, { recursive: true });
+
+    console.log('Step 3/3: Adding deployment configurations...');
+
+    writeFileSync(join(outputDir, 'vercel.json'), createVercelConfig());
+    writeFileSync(join(outputDir, 'netlify.toml'), createNetlifyConfig());
+    writeFileSync(join(outputDir, 'package.json'), createDeployPackageJson(name));
+
+    console.log('\n' + '='.repeat(50));
+    console.log('  Deployment package ready!');
+    console.log('='.repeat(50));
+    console.log(`\n  Output: ${outputDir}/`);
+    console.log('\n  Deploy with Vercel:');
+    console.log(`    cd ${outputDir} && vercel`);
+    console.log('\n  Deploy with Netlify:');
+    console.log(`    cd ${outputDir} && netlify deploy --prod`);
+    console.log('\n  Or push to Git and import in Vercel/Netlify dashboard.');
+    console.log('');
+  });
+}