@lumiflora/fsdk 0.1.4

package/dist/commands/completion.js

@@ -0,0 +1,271 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from '../utils/index.js';
+const BASH_COMPLETION = `#!/bin/bash
+# fsdk bash completion
+
+_fsdk_completion() {
+  local cur prev opts
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  opts="create add-page add-component add-store sync-template validate preview completion"
+
+  case "\${prev}" in
+    create)
+      opts="--template --package-manager --eslint --no-git --no-install"
+      ;;
+    add-page)
+      opts="--router-path --page-name"
+      ;;
+    add-component)
+      opts="--type --name --dir"
+      ;;
+    add-store)
+      opts="--type --name"
+      ;;
+    sync-template)
+      opts="--template --force"
+      ;;
+    validate)
+      opts="--config --templates --strict"
+      ;;
+    preview)
+      opts="--port --host --open --template"
+      ;;
+    completion)
+      opts="bash zsh fish"
+      ;;
+  esac
+
+  COMPREPLY=($(compgen -W "\${opts}" -- "\${cur}"))
+  return 0
+}
+
+complete -F _fsdk_completion fsdk
+`;
+const ZSH_COMPLETION = `#fsdk completion
+autoload -Uz compinit
+compinit 2>/dev/null
+
+# Define the completion function
+_fsdk() {
+  local -a _fsdk_cmds
+  _fsdk_cmds=(
+    'create:Create a new application'
+    'add-page:Add a new page'
+    'add-component:Add a new component'
+    'add-store:Add a new store'
+    'sync-template:Sync template files'
+    'validate:Validate configuration and templates'
+    'preview:Preview template'
+    'completion:Generate shell completion script'
+  )
+
+  _arguments -C \\
+    '1: :->command' \\
+    '2: :->args' \\
+    '*: :->rest'
+
+  case "$state" in
+    command)
+      _describe 'command' _fsdk_cmds
+      ;;
+    args)
+      case $words[1] in
+        create)
+          _arguments -s \\
+            '--template[Template name]' \\
+            '--package-manager[Package manager: npm|pnpm|yarn|bun]' \\
+            '--eslint[Enable ESLint]' \\
+            '--no-git[Skip git initialization]' \\
+            '--no-install[Skip dependency installation]'
+          ;;
+        add-page)
+          _arguments -s \\
+            '--router-path[Router path]' \\
+            '--page-name[Page name]'
+          ;;
+        add-component)
+          _arguments -s \\
+            '--type[Component type: page|common|business]' \\
+            '--name[Component name]' \\
+            '--dir[Subdirectory]'
+          ;;
+        add-store)
+          _arguments -s \\
+            '--type[Store type: pinia|redux]' \\
+            '--name[Store name]'
+          ;;
+        sync-template)
+          _arguments -s \\
+            '--template[Template name]' \\
+            '--force[Force sync]'
+          ;;
+        validate)
+          _arguments -s \\
+            '--config[Validate config only]' \\
+            '--templates[Validate templates only]' \\
+            '--strict[Strict validation]'
+          ;;
+        preview)
+          _arguments -s \\
+            '--port[Port number]' \\
+            '--host[Host address]' \\
+            '--open[Open browser]' \\
+            '--template[Template name]'
+          ;;
+        completion)
+          _arguments -s \\
+            'bash:Generate bash completion' \\
+            'zsh:Generate zsh completion' \\
+            'fish:Generate fish completion'
+          ;;
+      esac
+      ;;
+  esac
+}
+
+# Register the completion function for fsdk command
+compdef _fsdk fsdk
+`;
+const FISH_COMPLETION = `# fish completion for fsdk
+
+complete -c fsdk -n '__fish_use_subcommand' -a 'create' -d 'Create a new application'
+complete -c fsdk -n '__fish_use_subcommand' -a 'add-page' -d 'Add a new page'
+complete -c fsdk -n '__fish_use_subcommand' -a 'add-component' -d 'Add a new component'
+complete -c fsdk -n '__fish_use_subcommand' -a 'add-store' -d 'Add a new store'
+complete -c fsdk -n '__fish_use_subcommand' -a 'sync-template' -d 'Sync template files'
+complete -c fsdk -n '__fish_use_subcommand' -a 'validate' -d 'Validate configuration and templates'
+complete -c fsdk -n '__fish_use_subcommand' -a 'preview' -d 'Preview template'
+complete -c fsdk -n '__fish_use_subcommand' -a 'completion' -d 'Generate shell completion script'
+
+# create options
+complete -c fsdk -n '__fish_seen_subcommand_from create' -l template -d 'Template name'
+complete -c fsdk -n '__fish_seen_subcommand_from create' -l package-manager -d 'Package manager' -a 'npm pnpm yarn bun'
+complete -c fsdk -n '__fish_seen_subcommand_from create' -l eslint -d 'Enable ESLint'
+complete -c fsdk -n '__fish_seen_subcommand_from create' -l no-git -d 'Skip git initialization'
+complete -c fsdk -n '__fish_seen_subcommand_from create' -l no-install -d 'Skip dependency installation'
+
+# add-page options
+complete -c fsdk -n '__fish_seen_subcommand_from add-page' -l router-path -d 'Router path'
+complete -c fsdk -n '__fish_seen_subcommand_from add-page' -l page-name -d 'Page name'
+
+# add-component options
+complete -c fsdk -n '__fish_seen_subcommand_from add-component' -l type -d 'Component type' -a 'page common business'
+complete -c fsdk -n '__fish_seen_subcommand_from add-component' -l name -d 'Component name'
+complete -c fsdk -n '__fish_seen_subcommand_from add-component' -l dir -d 'Subdirectory'
+
+# add-store options
+complete -c fsdk -n '__fish_seen_subcommand_from add-store' -l type -d 'Store type' -a 'pinia redux'
+complete -c fsdk -n '__fish_seen_subcommand_from add-store' -l name -d 'Store name'
+
+# sync-template options
+complete -c fsdk -n '__fish_seen_subcommand_from sync-template' -l template -d 'Template name'
+complete -c fsdk -n '__fish_seen_subcommand_from sync-template' -l force -d 'Force sync'
+
+# validate options
+complete -c fsdk -n '__fish_seen_subcommand_from validate' -l config -d 'Validate config only'
+complete -c fsdk -n '__fish_seen_subcommand_from validate' -l templates -d 'Validate templates only'
+complete -c fsdk -n '__fish_seen_subcommand_from validate' -l strict -d 'Strict validation'
+
+# preview options
+complete -c fsdk -n '__fish_seen_subcommand_from preview' -l port -d 'Port number'
+complete -c fsdk -n '__fish_seen_subcommand_from preview' -l host -d 'Host address'
+complete -c fsdk -n '__fish_seen_subcommand_from preview' -l open -d 'Open browser'
+complete -c fsdk -n '__fish_seen_subcommand_from preview' -l template -d 'Template name'
+`;
+export async function generateCompletion(options = {}) {
+    const shell = options.shell || detectShell();
+    const outputPath = options.output || getDefaultOutputPath(shell);
+    const install = options.install || false;
+    try {
+        const content = getCompletionScript(shell);
+        await fs.ensureDir(path.dirname(outputPath));
+        await fs.writeFile(outputPath, content, 'utf-8');
+        if (shell === 'bash') {
+            fs.chmodSync(outputPath, 0o755);
+        }
+        logger.success(`Completion script for ${shell} generated at ${outputPath}`);
+        if (install && shell !== 'fish') {
+            await installToShellRc(shell, outputPath);
+        }
+        else if (!install) {
+            if (shell !== 'fish') {
+                logger.info(`Add the following line to your shell configuration:`);
+                logger.info(`  source ${outputPath}`);
+            }
+            else {
+                logger.info(`Add the following line to your fish config:`);
+                logger.info(`  source ${outputPath}`);
+            }
+        }
+    }
+    catch (error) {
+        logger.error('Failed to generate completion script:', error);
+        throw error;
+    }
+}
+async function installToShellRc(shell, completionPath) {
+    const home = process.env.HOME || '';
+    let rcFile = '';
+    let sourceLine = `source ${completionPath}`;
+    if (shell === 'bash') {
+        rcFile = path.resolve(home, '.bashrc');
+    }
+    else if (shell === 'zsh') {
+        rcFile = path.resolve(home, '.zshrc');
+    }
+    else {
+        logger.warning(`--install is not supported for fish shell yet`);
+        return;
+    }
+    try {
+        let rcContent = '';
+        if (await fs.pathExists(rcFile)) {
+            rcContent = await fs.readFile(rcFile, 'utf-8');
+        }
+        const pattern = shell === 'bash' ? /\.fsdk-completion/ : 'fsdk-completion';
+        if (rcContent.includes(pattern)) {
+            logger.info(`Completion already installed in ${rcFile}`);
+            return;
+        }
+        await fs.appendFile(rcFile, `\n# fsdk completion\n${sourceLine}\n`);
+        logger.success(`Completion installed to ${rcFile}`);
+        logger.info(`Run "source ${rcFile}" or restart your shell to apply`);
+    }
+    catch (error) {
+        logger.error(`Failed to install completion to ${rcFile}:`, error);
+        throw error;
+    }
+}
+function detectShell() {
+    const shell = process.env.SHELL || '';
+    if (shell.includes('zsh'))
+        return 'zsh';
+    if (shell.includes('fish'))
+        return 'fish';
+    return 'bash';
+}
+function getDefaultOutputPath(shell) {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    switch (shell) {
+        case 'bash':
+            return path.resolve(home, '.fsdk-completion.bash');
+        case 'zsh':
+            return path.resolve(home, '.fsdk-completion.zsh');
+        case 'fish':
+            return path.resolve(home, '.config', 'fish', 'completions', 'fsdk.fish');
+    }
+}
+function getCompletionScript(shell) {
+    switch (shell) {
+        case 'bash':
+            return BASH_COMPLETION;
+        case 'zsh':
+            return ZSH_COMPLETION;
+        case 'fish':
+            return FISH_COMPLETION;
+    }
+}

package/dist/commands/create-app.d.ts

@@ -0,0 +1,10 @@
+export interface CreateAppOptions {
+    template?: string;
+    packageManager?: 'npm' | 'pnpm' | 'yarn' | 'bun';
+    eslint?: boolean;
+    git?: boolean;
+    install?: boolean;
+    projectName?: string;
+}
+export declare function createApp(cwd: string, options?: CreateAppOptions): Promise<void>;
+//# sourceMappingURL=create-app.d.ts.map

package/dist/commands/create-app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-app.d.ts","sourceRoot":"","sources":["../../src/commands/create-app.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;IACjD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyF1F"}

package/dist/commands/create-app.js

@@ -0,0 +1,174 @@
+import prompts from 'prompts';
+import fs from 'fs-extra';
+import path from 'path';
+import { logger, Spinner, getTemplatesRoot } from '../utils/index.js';
+import { templateEngine } from '../core/index.js';
+import { spawn } from 'child_process';
+export async function createApp(cwd, options = {}) {
+    // Early check: if projectName is provided, verify directory doesn't exist
+    // This avoids wasting user time with prompts if directory already exists
+    if (options.projectName) {
+        const projectPath = path.resolve(cwd, options.projectName);
+        if (fs.existsSync(projectPath)) {
+            throw new Error(`Directory ${options.projectName} already exists`);
+        }
+    }
+    // First resolve options to determine if interactive mode
+    const resolvedOptions = await resolveOptions(options, cwd);
+    const { projectName, template, packageManager, eslint, git, install } = resolvedOptions;
+    const projectPath = path.resolve(cwd, projectName);
+    const isInteractive = !options.template;
+    // Only show info log in non-interactive mode
+    if (!isInteractive) {
+        logger.info('Creating new application...');
+    }
+    // Only use spinner in non-interactive mode (when template is provided)
+    const spinner = new Spinner(!isInteractive, 'Creating project...');
+    try {
+        if (fs.existsSync(projectPath)) {
+            spinner.fail(`Directory ${projectName} already exists`);
+            throw new Error(`Directory ${projectName} already exists`);
+        }
+        spinner.text = 'Creating project structure...';
+        await fs.ensureDir(projectPath);
+        // Copy root template files (package.json, tsconfig, vite.config, etc.)
+        const rootTemplatePath = path.resolve(getTemplatesRoot(), template);
+        const rootFiles = ['package.json', 'tsconfig.json', 'tsconfig.app.json', 'vite.config.ts', 'index.html', '.gitignore', 'eslint.config.mjs'];
+        await Promise.all(rootFiles.map(async (file) => {
+            const source = path.resolve(rootTemplatePath, file);
+            const dest = path.resolve(projectPath, file);
+            if (await fs.pathExists(source)) {
+                await fs.copy(source, dest);
+                // Update package.json name to project name
+                if (file === 'package.json') {
+                    const pkg = await fs.readJson(dest);
+                    pkg.name = projectName;
+                    await fs.writeJson(dest, pkg, { spaces: 2 });
+                }
+            }
+        }));
+        // Render src template files
+        spinner.text = 'Rendering template files...';
+        await templateEngine.renderDirectory({
+            templateName: template,
+            templateDir: 'src',
+            outputDir: path.resolve(projectPath, 'src'),
+            data: {
+                projectName,
+                packageManager,
+                eslint,
+                git,
+            },
+            excludes: ['**/node_modules/**'],
+        });
+        await templateEngine.copyPublicFiles(template, projectPath);
+        if (git) {
+            spinner.text = 'Initializing git repository...';
+            try {
+                await spawnCommand('git', ['init'], projectPath);
+            }
+            catch {
+                logger.warning('Failed to initialize git repository');
+            }
+        }
+        if (install) {
+            spinner.text = `Installing dependencies with ${packageManager}...`;
+            await spawnCommand(packageManager, ['install'], projectPath);
+        }
+        spinner.succeed(`Project ${projectName} created successfully!`);
+        logger.info(`cd ${projectName} to start developing`);
+    }
+    catch (error) {
+        spinner.fail('Failed to create project');
+        throw error;
+    }
+}
+async function resolveOptions(options, cwd) {
+    // If all required options are provided, use them directly (non-interactive mode)
+    if (options.projectName && options.template) {
+        return {
+            projectName: options.projectName,
+            template: options.template,
+            packageManager: options.packageManager || 'pnpm',
+            eslint: options.eslint ?? true,
+            git: options.git ?? true,
+            install: options.install ?? true,
+        };
+    }
+    // Otherwise, enter interactive mode
+    const responses = await prompts([
+        {
+            type: 'text',
+            name: 'projectName',
+            message: 'What is the project name?',
+            initial: 'my-app',
+            validate: (value) => /^[a-z0-9-]+$/.test(value) || 'Only lowercase letters, numbers, and hyphens are allowed',
+        },
+        {
+            type: 'select',
+            name: 'template',
+            message: 'Select a template',
+            choices: [
+                { title: 'Base', value: 'base', description: 'Basic template with Vite' },
+                { title: 'Full', value: 'full', description: 'Full-featured template with Vite + Element Plus + Pinia' },
+            ],
+            initial: 0,
+        },
+        {
+            type: 'select',
+            name: 'packageManager',
+            message: 'Select a package manager',
+            choices: [
+                { title: 'pnpm', value: 'pnpm' },
+                { title: 'npm', value: 'npm' },
+                { title: 'yarn', value: 'yarn' },
+                { title: 'bun', value: 'bun' },
+            ],
+            initial: 0,
+        },
+        {
+            type: 'confirm',
+            name: 'eslint',
+            message: 'Enable ESLint?',
+            initial: true,
+        },
+        {
+            type: 'confirm',
+            name: 'git',
+            message: 'Initialize git repository?',
+            initial: true,
+        },
+        {
+            type: 'confirm',
+            name: 'install',
+            message: 'Install dependencies?',
+            initial: true,
+        },
+    ]);
+    return {
+        projectName: options.projectName || responses.projectName,
+        template: options.template || responses.template,
+        packageManager: options.packageManager || responses.packageManager,
+        eslint: options.eslint ?? responses.eslint,
+        git: options.git ?? responses.git,
+        install: options.install ?? responses.install,
+    };
+}
+async function spawnCommand(cmd, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            cwd,
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Command ${cmd} ${args.join(' ')} exited with code ${code}`));
+            }
+        });
+        child.on('error', reject);
+    });
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,9 @@
+export { createApp, type CreateAppOptions } from './create-app.js';
+export { addPage, type AddPageOptions, syncPageRoutes } from './add-page.js';
+export { addComponent, type AddComponentOptions } from './add-component.js';
+export { addStore, type AddStoreOptions } from './add-store.js';
+export { syncTemplate, type SyncTemplateOptions } from './sync-template.js';
+export { validate, type ValidateOptions } from './validate.js';
+export { preview, type PreviewOptions } from './preview.js';
+export { generateCompletion, type CompletionOptions, type ShellType } from './completion.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,KAAK,iBAAiB,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/commands/index.js

@@ -0,0 +1,8 @@
+export { createApp } from './create-app.js';
+export { addPage, syncPageRoutes } from './add-page.js';
+export { addComponent } from './add-component.js';
+export { addStore } from './add-store.js';
+export { syncTemplate } from './sync-template.js';
+export { validate } from './validate.js';
+export { preview } from './preview.js';
+export { generateCompletion } from './completion.js';

package/dist/commands/preview.d.ts

@@ -0,0 +1,8 @@
+export interface PreviewOptions {
+    port?: number;
+    host?: string;
+    open?: boolean;
+    template?: string;
+}
+export declare function preview(cwd: string, options?: PreviewOptions): Promise<void>;
+//# sourceMappingURL=preview.d.ts.map

package/dist/commands/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/commands/preview.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkDtF"}

package/dist/commands/preview.js

@@ -0,0 +1,162 @@
+import { spawn } from 'child_process';
+import fs from 'fs-extra';
+import http from 'http';
+import path from 'path';
+import { logger } from '../utils/index.js';
+import { templateEngine } from '../core/index.js';
+import { hotReload } from '../core/index.js';
+import { resolveTemplatePath } from '../utils/path.js';
+export async function preview(cwd, options = {}) {
+    const port = options.port || 3000;
+    const host = options.host || 'localhost';
+    const templateName = options.template || 'base';
+    try {
+        const previewServerDir = path.resolve(cwd, '.fsdk', 'preview-temp');
+        await fs.ensureDir(previewServerDir);
+        logger.info(`Preparing preview server at http://${host}:${port}`);
+        // 监听模板源文件目录
+        const templateSrcDir = resolveTemplatePath(templateName, 'src');
+        const templatePublicDir = resolveTemplatePath(templateName, 'public');
+        const renderTemplate = async () => {
+            logger.info(`Re-rendering template: ${templateName}`);
+            await templateEngine.renderDirectory({
+                templateName,
+                outputDir: previewServerDir,
+                data: { port, host },
+            });
+            await templateEngine.copyPublicFiles(templateName, previewServerDir);
+            logger.success('Template re-rendered');
+        };
+        // 初始渲染
+        await renderTemplate();
+        await startPreviewServer(previewServerDir, port, host);
+        if (options.open) {
+            const openCmd = process.platform === 'win32' ? 'start' : (process.platform === 'darwin' ? 'open' : 'xdg-open');
+            spawn(openCmd, [`http://${host}:${port}`], { stdio: 'ignore', detached: true, shell: true });
+        }
+        await hotReload.start({
+            watchPaths: [templateSrcDir, templatePublicDir],
+            ignored: ['**/node_modules/**', '**/.git/**'],
+            onChange: async (event, file) => {
+                logger.info(`Template ${event}: ${path.relative(templateSrcDir, file) || path.relative(templatePublicDir, file)}`);
+                await renderTemplate();
+            },
+        });
+        logger.success('Preview server is running. Press Ctrl+C to stop.');
+    }
+    catch (error) {
+        logger.error('Failed to start preview server:', error);
+        throw error;
+    }
+}
+async function startPreviewServer(serverDir, port, host) {
+    const indexPath = path.resolve(serverDir, 'index.html');
+    if (!fs.existsSync(indexPath)) {
+        const html = generateDefaultHtml(port, host);
+        await fs.writeFile(indexPath, html);
+    }
+    return new Promise((resolve, reject) => {
+        const server = http.createServer(async (req, res) => {
+            try {
+                // Serve index.html for root path
+                if (req.url === '/' || req.url === '/index.html') {
+                    const content = await fs.readFile(indexPath, 'utf-8');
+                    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                    res.end(content);
+                    return;
+                }
+                // Try to serve static files
+                const filePath = path.join(serverDir, req.url || '');
+                if (await fs.pathExists(filePath)) {
+                    const ext = path.extname(filePath);
+                    const contentType = getContentType(ext);
+                    const content = await fs.readFile(filePath);
+                    res.writeHead(200, { 'Content-Type': contentType });
+                    res.end(content);
+                    return;
+                }
+                // 404 for unknown paths
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('Not Found');
+            }
+            catch (error) {
+                logger.error('Error serving file:', error);
+                res.writeHead(500, { 'Content-Type': 'text/plain' });
+                res.end('Internal Server Error');
+            }
+        });
+        server.listen(port, host, () => {
+            logger.info(`Preview server running at http://${host}:${port}`);
+            // Handle graceful shutdown
+            server.on('close', () => {
+                logger.debug('Preview server closed');
+            });
+            resolve();
+        });
+        server.on('error', (error) => {
+            if (error.code === 'EADDRINUSE') {
+                reject(new Error(`Port ${port} is already in use`));
+            }
+            else {
+                reject(error);
+            }
+        });
+        // Store server reference for shutdown
+        global.__previewServer = server;
+    });
+}
+function getContentType(ext) {
+    const contentTypes = {
+        '.html': 'text/html; charset=utf-8',
+        '.css': 'text/css; charset=utf-8',
+        '.js': 'application/javascript; charset=utf-8',
+        '.json': 'application/json',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.svg': 'image/svg+xml',
+        '.ico': 'image/x-icon',
+        '.woff': 'font/woff',
+        '.woff2': 'font/woff2',
+        '.ttf': 'font/ttf',
+        '.eot': 'application/vnd.ms-fontobject',
+    };
+    return contentTypes[ext] || 'application/octet-stream';
+}
+function generateDefaultHtml(port, host) {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Fsdk Preview</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background: #f5f5f5;
+    }
+    .container {
+      text-align: center;
+      padding: 40px;
+      background: white;
+      border-radius: 8px;
+      box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+    }
+    h1 { color: #333; }
+    p { color: #666; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Fsdk Preview</h1>
+    <p>Server running at http://${host}:${port}</p>
+  </div>
+</body>
+</html>
+`;
+}

package/dist/commands/sync-template.d.ts

@@ -0,0 +1,6 @@
+export interface SyncTemplateOptions {
+    template?: string;
+    force?: boolean;
+}
+export declare function syncTemplate(cwd: string, options?: SyncTemplateOptions): Promise<void>;
+//# sourceMappingURL=sync-template.d.ts.map

package/dist/commands/sync-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-template.d.ts","sourceRoot":"","sources":["../../src/commands/sync-template.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2ChG"}