supaslidev 0.1.4 → 0.2.0

package/src/cli/commands/dev.ts

@@ -0,0 +1,116 @@
+import { spawn, ChildProcess } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { findProjectRoot } from '../utils.js';
+
+export function findSupaslidevPackageRoot(): string {
+  let dir = dirname(fileURLToPath(import.meta.url));
+
+  while (dir !== dirname(dir)) {
+    const packageJsonPath = join(dir, 'package.json');
+    if (existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        if (pkg.name === 'supaslidev') {
+          return dir;
+        }
+      } catch {
+        // Continue searching
+      }
+    }
+    dir = dirname(dir);
+  }
+
+  throw new Error('Could not find supaslidev package root');
+}
+
+export async function dev(): 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);
+  }
+
+  console.log(`Starting Supaslidev for project: ${projectRoot}`);
+  console.log(`Presentations directory: ${presentationsDir}`);
+
+  process.env.SUPASLIDEV_PROJECT_ROOT = projectRoot;
+  process.env.SUPASLIDEV_PRESENTATIONS_DIR = presentationsDir;
+
+  // Run Nuxt from the supaslidev package root so its nuxt.config.ts,
+  // app/, server/, and public/ directories are used directly — this avoids
+  // the Nuxt layer `extends` mechanism which can trigger Vite module
+  // resolution conflicts when the package is installed from a tarball.
+  const supaslidevRoot = findSupaslidevPackageRoot();
+
+  // Find the nuxt binary — prefer the project's node_modules, then
+  // the supaslidev package's own node_modules, then fall back to npx.
+  const projectNuxtBin = join(projectRoot, 'node_modules', '.bin', 'nuxt');
+  const packageNuxtBin = join(supaslidevRoot, 'node_modules', '.bin', 'nuxt');
+
+  let command: string;
+  let args: string[];
+
+  if (existsSync(projectNuxtBin)) {
+    command = projectNuxtBin;
+    args = ['dev'];
+  } else if (existsSync(packageNuxtBin)) {
+    command = packageNuxtBin;
+    args = ['dev'];
+  } else {
+    command = 'npx';
+    args = ['nuxt', 'dev'];
+  }
+
+  // Build a clean env for nuxt dev: always run in development mode
+  // and strip test runner env vars (VITEST, etc.) that cause Nuxt to
+  // skip the dev server startup.
+  const nuxtEnv: Record<string, string | undefined> = { ...process.env, NODE_ENV: 'development' };
+  for (const key of Object.keys(nuxtEnv)) {
+    if (key === 'VITEST' || key.startsWith('VITEST_') || key === 'TEST') {
+      delete nuxtEnv[key];
+    }
+  }
+
+  const nuxt = spawn(command, args, {
+    cwd: supaslidevRoot,
+    stdio: 'inherit',
+    env: nuxtEnv,
+    shell: process.platform === 'win32',
+    detached: false,
+  });
+
+  const processes: ChildProcess[] = [nuxt];
+
+  nuxt.on('error', (err) => {
+    console.error(`Failed to start Nuxt: ${err.message}`);
+    process.exit(1);
+  });
+
+  nuxt.on('close', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+    } else {
+      process.exit(code ?? 1);
+    }
+  });
+
+  const cleanup = () => {
+    for (const proc of processes) {
+      proc.kill('SIGTERM');
+    }
+  };
+
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+}

package/src/cli/commands/export.ts

@@ -0,0 +1,63 @@
+import { spawn } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { existsSync, mkdirSync } from 'node:fs';
+import { findProjectRoot, getPresentations, printAvailablePresentations } from '../utils.js';
+
+export interface ExportOptions {
+  output?: string;
+}
+
+export async function exportPdf(name: string, options: ExportOptions = {}): 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 distDir = join(projectRoot, 'dist');
+  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 outputPath = options.output ?? join(distDir, `${name}.pdf`);
+
+  if (!existsSync(dirname(outputPath))) {
+    mkdirSync(dirname(outputPath), { recursive: true });
+  }
+
+  console.log('\n' + '='.repeat(50));
+  console.log(`  Exporting PDF: ${name}`);
+  console.log(`  Output: ${outputPath}`);
+  console.log('='.repeat(50) + '\n');
+
+  const slidev = spawn('npx', ['slidev', 'export', '--output', outputPath], {
+    cwd: presentationDir,
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  slidev.on('error', (err) => {
+    console.error(`Failed to export presentation: ${err.message}`);
+    process.exit(1);
+  });
+
+  slidev.on('close', (code) => {
+    if (code !== 0) {
+      console.error(`\nExport failed with exit code ${code}`);
+      process.exit(code ?? 1);
+    }
+
+    console.log('\n' + '='.repeat(50));
+    console.log(`  Export complete!`);
+    console.log(`  Output: ${outputPath}`);
+    console.log('='.repeat(50) + '\n');
+  });
+}

package/src/cli/commands/import.ts

@@ -0,0 +1,178 @@
+import { spawn } from 'node:child_process';
+import { join, basename, resolve, dirname } from 'node:path';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { addImportedPresentation, findWorkspaceRoot } from 'create-supaslidev';
+import { findProjectRoot, getPresentations } from '../utils.js';
+import {
+  IGNORE_PATTERNS,
+  validateName,
+  validateSourceDirectory,
+  copyDirectorySelective,
+  hasSharedPackage,
+  addSharedAddonToSlides,
+  addSharedDependencyToPackageJson,
+} from '../../shared/index.js';
+import type { PackageJson } from '../../shared/types.js';
+
+// Re-export for tests and other consumers
+export {
+  IGNORE_PATTERNS,
+  validateName,
+  shouldIgnore,
+  validateSourceDirectory,
+  copyDirectorySelective,
+} from '../../shared/index.js';
+
+export function findPnpmWorkspaceRoot(startDir: string): string | null {
+  let currentDir = startDir;
+  while (currentDir !== dirname(currentDir)) {
+    if (existsSync(join(currentDir, 'pnpm-workspace.yaml'))) {
+      return currentDir;
+    }
+    currentDir = dirname(currentDir);
+  }
+  return null;
+}
+
+export function transformPackageJson(
+  sourcePath: string,
+  name: string,
+  projectRoot: string,
+): string {
+  const packageJsonPath = join(sourcePath, 'package.json');
+  const content = readFileSync(packageJsonPath, 'utf-8');
+  const packageJson = JSON.parse(content) as PackageJson;
+
+  packageJson.name = `@supaslidev/${name}`;
+  packageJson.private = true;
+
+  packageJson.scripts = {
+    dev: 'slidev --open',
+    build: 'slidev build',
+    export: 'slidev export',
+  };
+
+  if (hasSharedPackage(projectRoot)) {
+    addSharedDependencyToPackageJson(packageJson);
+  }
+
+  return JSON.stringify(packageJson, null, 2) + '\n';
+}
+
+function runPnpmInstall(projectRoot: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    console.log('\nRunning pnpm install...');
+
+    const child = spawn('pnpm', ['install'], {
+      cwd: projectRoot,
+      stdio: 'inherit',
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`pnpm install failed with exit code ${code}`));
+        return;
+      }
+      resolve();
+    });
+
+    child.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+export interface ImportOptions {
+  name?: string;
+  install?: boolean;
+}
+
+export async function importPresentation(
+  source: string,
+  options: ImportOptions = {},
+): Promise<void> {
+  const { name, install = true } = options;
+  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);
+  }
+
+  const sourcePath = resolve(source);
+
+  try {
+    validateSourceDirectory(sourcePath);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : 'Invalid source'}`);
+    process.exit(1);
+  }
+
+  const presentationName =
+    name ??
+    basename(sourcePath)
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-');
+
+  try {
+    validateName(presentationName);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : 'Invalid name'}`);
+    process.exit(1);
+  }
+
+  const existingPresentations = getPresentations(presentationsDir);
+  if (existingPresentations.includes(presentationName)) {
+    console.error(`Error: Presentation "${presentationName}" already exists`);
+    process.exit(1);
+  }
+
+  const destinationPath = join(presentationsDir, presentationName);
+
+  console.log(`Importing presentation from: ${sourcePath}`);
+  console.log(`Destination: ${destinationPath}`);
+
+  copyDirectorySelective(sourcePath, destinationPath);
+
+  const transformedPackageJson = transformPackageJson(sourcePath, presentationName, projectRoot);
+  writeFileSync(join(destinationPath, 'package.json'), transformedPackageJson);
+
+  if (hasSharedPackage(projectRoot)) {
+    const slidesPath = join(destinationPath, 'slides.md');
+    if (existsSync(slidesPath)) {
+      addSharedAddonToSlides(slidesPath);
+    }
+  }
+
+  console.log('\nFiles copied successfully!');
+  console.log('Ignored: ' + IGNORE_PATTERNS.join(', '));
+
+  const workspaceRoot = findWorkspaceRoot(projectRoot);
+  const pnpmRoot = findPnpmWorkspaceRoot(projectRoot);
+
+  if (install) {
+    await runPnpmInstall(pnpmRoot ?? projectRoot);
+  } else {
+    console.log(
+      '\nSkipped pnpm install. Run "pnpm install" manually before using the presentation.',
+    );
+  }
+  if (workspaceRoot) {
+    addImportedPresentation(workspaceRoot, {
+      name: presentationName,
+      importedAt: new Date().toISOString(),
+      sourcePath,
+    });
+  }
+
+  console.log('\nPresentation imported successfully!');
+  console.log(`Run "supaslidev present ${presentationName}" to start a dev server.`);
+}

package/src/cli/commands/present.ts

@@ -0,0 +1,111 @@
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { findProjectRoot } from '../utils.js';
+
+function tryOpenBrowser(url: string): void {
+  const cmd =
+    process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+
+  try {
+    const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+    child.on('error', () => {
+      console.log(`\n  Open ${url} in your browser\n`);
+    });
+    child.unref();
+  } catch {
+    console.log(`\n  Open ${url} in your browser\n`);
+  }
+}
+
+function getPresentations(presentationsDir: string): string[] {
+  if (!existsSync(presentationsDir)) {
+    return [];
+  }
+
+  return readdirSync(presentationsDir)
+    .filter((name) => {
+      const fullPath = join(presentationsDir, name);
+      return statSync(fullPath).isDirectory() && existsSync(join(fullPath, 'slides.md'));
+    })
+    .sort();
+}
+
+function printAvailable(presentations: string[]): void {
+  console.error('\nAvailable presentations:');
+
+  if (presentations.length === 0) {
+    console.error('  No presentations found');
+  } else {
+    presentations.forEach((name) => {
+      console.error(`  ${name}`);
+    });
+  }
+}
+
+export async function present(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);
+  }
+
+  const presentations = getPresentations(presentationsDir);
+
+  if (!presentations.includes(name)) {
+    console.error(`Error: Presentation "${name}" not found`);
+    printAvailable(presentations);
+    process.exit(1);
+  }
+
+  const presentationPath = join(projectRoot, 'presentations', name);
+  const slidevBin = join(presentationPath, 'node_modules', '.bin', 'slidev');
+
+  console.log(`\nStarting dev server for ${name}...\n`);
+
+  return new Promise((resolve, reject) => {
+    const slidev = spawn(slidevBin, ['--open', 'false'], {
+      cwd: presentationPath,
+      stdio: ['inherit', 'pipe', 'inherit'],
+      shell: true,
+    });
+
+    let browserOpened = false;
+
+    slidev.stdout?.on('data', (data: Buffer) => {
+      const text = data.toString();
+      process.stdout.write(text);
+
+      if (!browserOpened) {
+        const match = text.match(/https?:\/\/localhost:\d+/);
+        if (match) {
+          browserOpened = true;
+          tryOpenBrowser(match[0]);
+        }
+      }
+    });
+
+    slidev.on('error', (err) => {
+      console.error(`Failed to start dev server: ${err.message}`);
+      reject(err);
+    });
+
+    slidev.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`Process exited with code ${code}`));
+        return;
+      }
+      resolve();
+    });
+  });
+}

package/src/cli/index.ts

@@ -0,0 +1,87 @@
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { Command } from 'commander';
+import { dev } from './commands/dev.js';
+import { create } from './commands/create.js';
+import { present } from './commands/present.js';
+import { exportPdf } from './commands/export.js';
+import { deploy } from './commands/deploy.js';
+import { importPresentation } from './commands/import.js';
+
+const program = new Command();
+
+program.name('supaslidev').description('Supaslidev presentation management CLI').version('0.1.0');
+
+program
+  .command('dev', { isDefault: true })
+  .description('Start the Supaslidev UI and development server')
+  .action(async () => {
+    await dev();
+  });
+
+program
+  .command('new')
+  .description('Create a new presentation')
+  .argument('[name]', 'Name of the presentation')
+  .action(async (name?: string) => {
+    await create(name);
+  });
+
+program
+  .command('present')
+  .description('Start a presentation dev server')
+  .argument('<name>', 'Name of the presentation to start')
+  .action(async (name: string) => {
+    await present(name);
+  });
+
+program
+  .command('export')
+  .description('Export a presentation to PDF')
+  .argument('<name>', 'Name of the presentation to export')
+  .option('-o, --output <path>', 'Output path for the PDF')
+  .action(async (name: string, options: { output?: string }) => {
+    await exportPdf(name, options);
+  });
+
+program
+  .command('deploy')
+  .description('Build and prepare a presentation for deployment')
+  .argument('<name>', 'Name of the presentation to deploy')
+  .option('-o, --output <path>', 'Output directory for deployment files')
+  .action(async (name: string, options: { output?: string }) => {
+    await deploy(name, options);
+  });
+
+program
+  .command('import')
+  .description('Import existing Sli.dev presentation(s)')
+  .argument('<source>', 'Path to existing Slidev presentation directory')
+  .option(
+    '-n, --name <name>',
+    'Name for the imported presentation (defaults to source directory name)',
+  )
+  .option('--no-install', 'Skip pnpm install after import')
+  .action(async (source: string, options: { name?: string; install?: boolean }) => {
+    await importPresentation(source, { name: options.name, install: options.install ?? true });
+  });
+
+export async function run(): Promise<void> {
+  await program.parseAsync();
+}
+
+function isMainModule(): boolean {
+  if (!process.argv[1]) return false;
+
+  try {
+    const scriptPath = realpathSync(process.argv[1]);
+    const modulePath = realpathSync(fileURLToPath(import.meta.url));
+    return scriptPath === modulePath;
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule()) {
+  run();
+}

package/src/cli/utils.ts

@@ -0,0 +1,94 @@
+import { dirname, join } from 'node:path';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+
+export function findProjectRoot(cwd: string = process.cwd()): string | null {
+  let dir = cwd;
+
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, 'presentations')) && existsSync(join(dir, 'package.json'))) {
+      return dir;
+    }
+    if (existsSync(join(dir, 'pnpm-workspace.yaml'))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+
+  if (existsSync(join(cwd, 'presentations'))) {
+    return cwd;
+  }
+
+  return null;
+}
+
+export function getPresentations(presentationsDir: string): string[] {
+  if (!existsSync(presentationsDir)) {
+    return [];
+  }
+
+  return readdirSync(presentationsDir)
+    .filter((name) => {
+      const fullPath = join(presentationsDir, name);
+      return statSync(fullPath).isDirectory() && existsSync(join(fullPath, 'slides.md'));
+    })
+    .sort();
+}
+
+export function printAvailablePresentations(presentations: string[]): void {
+  console.error('\nAvailable presentations:');
+
+  if (presentations.length === 0) {
+    console.error('  No presentations found');
+  } else {
+    for (const name of presentations) {
+      console.error(`  ${name}`);
+    }
+  }
+}
+
+export function createVercelConfig(): string {
+  return (
+    JSON.stringify(
+      {
+        buildCommand: 'npm run build',
+        outputDirectory: 'dist',
+        rewrites: [{ source: '/(.*)', destination: '/index.html' }],
+      },
+      null,
+      2,
+    ) + '\n'
+  );
+}
+
+export function createNetlifyConfig(): string {
+  return `[build]
+publish = "dist"
+command = "npm run build"
+
+[build.environment]
+NODE_VERSION = "20"
+
+[[redirects]]
+from = "/*"
+to = "/index.html"
+status = 200
+`;
+}
+
+export function createDeployPackageJson(name: string): string {
+  return (
+    JSON.stringify(
+      {
+        name: `${name}-deploy`,
+        version: '1.0.0',
+        private: true,
+        scripts: {
+          build: 'echo "Already built - static files ready in dist/"',
+          start: 'npx serve dist',
+        },
+      },
+      null,
+      2,
+    ) + '\n'
+  );
+}

package/src/config.ts

@@ -0,0 +1,21 @@
+type DateString = `${number}-${number}-${number}`;
+
+const DEFAULT_COMPAT_DATE: DateString = '2025-05-01';
+
+export function defineSupaslidevConfig<T extends Record<string, unknown>>(
+  userConfig: T = {} as T,
+): T & { extends: string[]; compatibilityDate: DateString } {
+  const configExtends = (userConfig as Record<string, unknown>).extends;
+  let userExtends: unknown[] = [];
+  if (Array.isArray(configExtends)) {
+    userExtends = configExtends;
+  } else if (configExtends) {
+    userExtends = [configExtends];
+  }
+
+  return {
+    ...userConfig,
+    extends: ['supaslidev/layer', ...userExtends],
+    compatibilityDate: (userConfig.compatibilityDate as DateString) ?? DEFAULT_COMPAT_DATE,
+  } as T & { extends: string[]; compatibilityDate: DateString };
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { defineSupaslidevConfig } from './config.js';
+export type { Presentation, PackageJson } from './shared/types.js';

package/src/module.ts

@@ -0,0 +1,12 @@
+import { defineNuxtModule } from '@nuxt/kit';
+
+export default defineNuxtModule({
+  meta: {
+    name: 'supaslidev',
+    configKey: 'supaslidev',
+  },
+  setup() {
+    // Runtime config is handled via nuxt.config.ts and env vars
+    // This module is a placeholder for future supaslidev-specific setup
+  },
+});