@sansavision/create-pulse 0.4.0 → 0.4.2

package/templates/react-queue-demo/src/App.tsx

@@ -1,14 +1,16 @@
-import { useState, useEffect, useCallback } from 'react'
-import { Pulse } from '@sansavision/pulse-sdk'
+import { useState, useEffect, useCallback, useRef } from 'react'
+import { Pulse, PulseQueue, PulseConnection, ConnectionMetrics } from '@sansavision/pulse-sdk'
+import type { QueueMessage } from '@sansavision/pulse-sdk'
 
 /**
- * Pulse v0.4.0 — Durable Queue Demo
+ * Pulse v0.4.4 — Durable Queue Demo
  *
  * This template demonstrates the persistent message queue system with:
- * - Publisher → Queue → Consumer flow over PLP
- * - At-least-once delivery semantics
- * - Dead-letter queue visibility
- * - Real-time metrics (RTT, packet loss)
+ * - Publisher → Queue → Consumer flow via the typed PulseQueue API
+ * - At-least-once delivery semantics via pull + ack
+ * - Auto-queue creation on first publish
+ * - Persistent messages surviving page refresh (when using redis/wal/postgres)
+ * - Configurable message TTL (time-to-live)
  *
  * Server-side queue backends (configured via PULSE_QUEUE_BACKEND env var):
  * - memory:   In-memory (default, ephemeral)
@@ -17,86 +19,188 @@ import { Pulse } from '@sansavision/pulse-sdk'
  * - redis:    Redis (shared state / cache)
  */
 
-interface QueueMessage {
-    id: string
-    payload: string
-    timestamp: number
-    state: 'pending' | 'in_flight' | 'acked' | 'dead_lettered'
+interface DisplayMessage extends QueueMessage {
+    state: 'pending' | 'acked'
 }
 
+const QUEUE_NAME = 'task-queue'
+
+const TTL_OPTIONS = [
+    { label: 'No TTL', value: undefined },
+    { label: '30s', value: 30 },
+    { label: '1 min', value: 60 },
+    { label: '5 min', value: 300 },
+    { label: '15 min', value: 900 },
+    { label: '1 hour', value: 3600 },
+    { label: '24 hours', value: 86400 },
+]
+
 export default function App() {
-    const [connected, setConnected] = useState(false)
-    const [messages, setMessages] = useState<QueueMessage[]>([])
+    const [connectionState, setConnectionState] = useState<'connecting' | 'connected' | 'reconnecting' | 'disconnected'>('connecting')
+    const [messages, setMessages] = useState<DisplayMessage[]>([])
     const [input, setInput] = useState('')
     const [rtt, setRtt] = useState<number | null>(null)
-    const [conn, setConn] = useState<any>(null)
+    const [queueDepth, setQueueDepth] = useState(0)
+    const [ttlSecs, setTtlSecs] = useState<number | undefined>(undefined)
+    const [customTtl, setCustomTtl] = useState('')
+    const [showCustomTtl, setShowCustomTtl] = useState(false)
+    const connRef = useRef<PulseConnection | null>(null)
+    const queueRef = useRef<PulseQueue | null>(null)
+
+    const connected = connectionState === 'connected'
 
+    // Helper: drain persisted messages and refresh depth
+    const recoverMessages = useCallback(async (queue: PulseQueue) => {
+        try {
+            const recovered = await queue.drain()
+            if (recovered.length > 0) {
+                setMessages(recovered.map((m) => ({ ...m, state: 'pending' as const })))
+            }
+            await refreshDepth(queue)
+        } catch {
+            // Queue may not exist yet — that's fine, it'll be auto-created
+        }
+    }, [])
+
+    // Connect + auto-fetch existing messages on mount
+    // Auto-reconnect is enabled by default in the SDK — the protocol "just works"
     useEffect(() => {
         const pulse = new Pulse({ apiKey: 'dev' })
 
-        pulse.connect('ws://localhost:4001').then((connection) => {
-            setConn(connection)
-            setConnected(true)
+        setConnectionState('connecting')
 
-            // Subscribe to queue stream
-            const stream = connection.stream('task-queue', { qos: 'durable' })
-            stream.on('data', (bytes: Uint8Array) => {
-                const msg = JSON.parse(new TextDecoder().decode(bytes))
-                setMessages((prev) => [...prev, msg])
-            })
+        pulse.connect('ws://localhost:4001').then(async (connection) => {
+            connRef.current = connection
+            const queue = new PulseQueue(connection, QUEUE_NAME, 'demo-ui')
+            queueRef.current = queue
+            setConnectionState('connected')
 
             // Live metrics
-            connection.on('metrics', (m: any) => setRtt(m.rtt))
+            connection.on('metrics', (m: ConnectionMetrics) => setRtt(m.rtt))
+
+            // Connection lifecycle events
+            connection.on('disconnect', () => setConnectionState('reconnecting'))
+            connection.on('reconnecting', () => setConnectionState('reconnecting'))
+            connection.on('reconnected', async () => {
+                setConnectionState('connected')
+                // Re-drain persisted messages after reconnect
+                await recoverMessages(queue)
+            })
+
+            // Drain any persisted messages from a previous session
+            await recoverMessages(queue)
         })
 
         return () => {
-            conn?.close()
+            connRef.current?.disconnect()
         }
-    }, [])
+    }, [recoverMessages])
+
+    const refreshDepth = async (queue?: PulseQueue) => {
+        const q = queue || queueRef.current
+        if (!q) return
+        try {
+            const info = await q.info()
+            if (info?.depth !== undefined) {
+                setQueueDepth(info.depth)
+            }
+        } catch {
+            // queue may not exist yet
+        }
+    }
 
+    // Publish a message via PulseQueue
     const publish = useCallback(async () => {
-        if (!conn || !input.trim()) return
+        const queue = queueRef.current
+        if (!queue || !input.trim()) return
+
+        try {
+            const result = await queue.publish(input.trim(), {
+                ttlSecs: ttlSecs,
+            })
+
+            if (result?.status === 'enqueued') {
+                // Immediately pull for display
+                const msg = await queue.pull()
+
+                if (msg) {
+                    setMessages((prev) => [
+                        ...prev,
+                        { ...msg, state: 'pending' as const },
+                    ])
+                }
+            }
 
-        const msg: QueueMessage = {
-            id: crypto.randomUUID(),
-            payload: input.trim(),
-            timestamp: Date.now(),
-            state: 'pending',
+            setInput('')
+            await refreshDepth()
+        } catch (err) {
+            console.error('Enqueue failed:', err)
         }
+    }, [input, ttlSecs])
 
-        const stream = conn.stream('task-queue', { qos: 'durable' })
-        stream.send(new TextEncoder().encode(JSON.stringify(msg)))
-        setMessages((prev) => [...prev, msg])
-        setInput('')
-    }, [conn, input])
+    // ACK a message by sequence number
+    const ackMessage = useCallback(async (sequence: number) => {
+        const queue = queueRef.current
+        if (!queue) return
 
-    const ackMessage = useCallback(async (id: string) => {
-        if (!conn) return
-        await conn.service('queue', 'ack', { queue: 'task-queue', message_id: id })
-        setMessages((prev) =>
-            prev.map((m) => (m.id === id ? { ...m, state: 'acked' as const } : m))
-        )
-    }, [conn])
+        try {
+            const result = await queue.ack(sequence)
+
+            if (result?.status === 'acked') {
+                setMessages((prev) =>
+                    prev.map((m) =>
+                        m.sequence === sequence ? { ...m, state: 'acked' as const } : m
+                    )
+                )
+            }
+            await refreshDepth()
+        } catch (err) {
+            console.error('Ack failed:', err)
+        }
+    }, [])
+
+    const handleTtlChange = (value: string) => {
+        if (value === 'custom') {
+            setShowCustomTtl(true)
+        } else {
+            setShowCustomTtl(false)
+            setTtlSecs(value === '' ? undefined : parseInt(value, 10))
+        }
+    }
+
+    const applyCustomTtl = () => {
+        const val = parseInt(customTtl, 10)
+        if (!isNaN(val) && val > 0) {
+            setTtlSecs(val)
+            setShowCustomTtl(false)
+        }
+    }
 
     return (
         <div style={{ fontFamily: 'Inter, system-ui, sans-serif', maxWidth: 720, margin: '0 auto', padding: 32 }}>
             <h1>🔄 Pulse Queue Demo</h1>
             <p style={{ color: '#888' }}>
                 Durable message queues with at-least-once delivery over PLP.
-                {connected ? (
+                {connectionState === 'connected' ? (
                     <span style={{ color: '#4ade80' }}> ● Connected</span>
+                ) : connectionState === 'reconnecting' ? (
+                    <span style={{ color: '#fbbf24' }}> ◌ Reconnecting...</span>
                 ) : (
                     <span style={{ color: '#f87171' }}> ○ Connecting...</span>
                 )}
                 {rtt !== null && <span style={{ marginLeft: 12 }}>RTT: {rtt}ms</span>}
+                <span style={{ marginLeft: 12, color: '#60a5fa' }}>
+                    Depth: {queueDepth}
+                </span>
             </p>
 
-            <div style={{ display: 'flex', gap: 8, marginBottom: 24 }}>
+            {/* Message input + TTL controls */}
+            <div style={{ display: 'flex', gap: 8, marginBottom: 8 }}>
                 <input
                     value={input}
                     onChange={(e) => setInput(e.target.value)}
                     onKeyDown={(e) => e.key === 'Enter' && publish()}
-                    placeholder="Enter a task message..."
+                    placeholder="Enter a message..."
                     style={{
                         flex: 1, padding: '10px 16px', borderRadius: 8,
                         border: '1px solid #333', background: '#1a1a2e', color: '#fff', fontSize: 14
@@ -114,23 +218,74 @@ export default function App() {
                 </button>
             </div>
 
+            {/* TTL Selector */}
+            <div style={{ display: 'flex', gap: 8, marginBottom: 24, alignItems: 'center' }}>
+                <label style={{ fontSize: 13, color: '#9ca3af', whiteSpace: 'nowrap' }}>⏱ TTL:</label>
+                <select
+                    value={showCustomTtl ? 'custom' : (ttlSecs === undefined ? '' : String(ttlSecs))}
+                    onChange={(e) => handleTtlChange(e.target.value)}
+                    style={{
+                        padding: '6px 12px', borderRadius: 6,
+                        border: '1px solid #333', background: '#1a1a2e', color: '#fff',
+                        fontSize: 13, cursor: 'pointer', minWidth: 100,
+                    }}
+                >
+                    {TTL_OPTIONS.map((opt) => (
+                        <option key={opt.label} value={opt.value === undefined ? '' : String(opt.value)}>
+                            {opt.label}
+                        </option>
+                    ))}
+                    <option value="custom">Custom...</option>
+                </select>
+                {showCustomTtl && (
+                    <div style={{ display: 'flex', gap: 4, alignItems: 'center' }}>
+                        <input
+                            type="number"
+                            min="1"
+                            value={customTtl}
+                            onChange={(e) => setCustomTtl(e.target.value)}
+                            onKeyDown={(e) => e.key === 'Enter' && applyCustomTtl()}
+                            placeholder="seconds"
+                            style={{
+                                width: 80, padding: '6px 10px', borderRadius: 6,
+                                border: '1px solid #333', background: '#1a1a2e', color: '#fff', fontSize: 13
+                            }}
+                        />
+                        <button
+                            onClick={applyCustomTtl}
+                            style={{
+                                padding: '6px 10px', borderRadius: 6, border: 'none',
+                                background: '#3b82f6', color: '#fff', fontSize: 12, cursor: 'pointer'
+                            }}
+                        >
+                            Set
+                        </button>
+                    </div>
+                )}
+                {ttlSecs !== undefined && !showCustomTtl && (
+                    <span style={{ fontSize: 12, color: '#60a5fa' }}>
+                        Messages expire after {ttlSecs}s
+                    </span>
+                )}
+            </div>
+
             <h2>Messages ({messages.length})</h2>
             <div style={{ display: 'flex', flexDirection: 'column', gap: 8 }}>
                 {messages.map((msg) => (
                     <div
-                        key={msg.id}
+                        key={msg.sequence}
                         style={{
                             padding: 16, borderRadius: 8,
-                            background: msg.state === 'acked' ? '#064e3b' : msg.state === 'dead_lettered' ? '#7f1d1d' : '#1e1b4b',
+                            background: msg.state === 'acked' ? '#064e3b' : '#1e1b4b',
                             display: 'flex', justifyContent: 'space-between', alignItems: 'center'
                         }}
                     >
                         <div>
                             <strong>{msg.payload}</strong>
                             <div style={{ fontSize: 12, color: '#888', marginTop: 4 }}>
-                                {msg.id.slice(0, 8)} · {new Date(msg.timestamp).toLocaleTimeString()} ·{' '}
+                                seq:{msg.sequence} · deliveries:{msg.delivery_count} ·{' '}
                                 <span style={{
-                                    color: msg.state === 'acked' ? '#4ade80' : msg.state === 'dead_lettered' ? '#f87171' : '#facc15'
+                                    color: msg.state === 'acked' ? '#4ade80' : '#facc15'
                                 }}>
                                     {msg.state}
                                 </span>
@@ -138,7 +293,7 @@ export default function App() {
                         </div>
                         {msg.state === 'pending' && (
                             <button
-                                onClick={() => ackMessage(msg.id)}
+                                onClick={() => ackMessage(msg.sequence)}
                                 style={{
                                     padding: '6px 12px', borderRadius: 6, border: 'none',
                                     background: '#22c55e', color: '#000', fontWeight: 600, cursor: 'pointer'
@@ -152,19 +307,31 @@ export default function App() {
             </div>
 
             <div style={{ marginTop: 32, padding: 16, borderRadius: 8, background: '#111827', fontSize: 13, color: '#9ca3af' }}>
-                <strong style={{ color: '#e5e7eb' }}>Server Configuration</strong>
+                <strong style={{ color: '#e5e7eb' }}>How it works</strong>
+                <ul style={{ marginTop: 8, paddingLeft: 20, lineHeight: 1.8 }}>
+                    <li><strong>Publish</strong> → <code>queue.publish(payload, {'{ ttlSecs? }'})</code></li>
+                    <li><strong>Consume</strong> → <code>queue.pull()</code></li>
+                    <li><strong>ACK</strong> → <code>queue.ack(sequence)</code></li>
+                    <li><strong>Recover</strong> → <code>queue.drain()</code> — pulls all pending messages</li>
+                    <li>Messages persist in the configured backend (redis/wal/postgres)</li>
+                    <li>Set <strong>TTL</strong> to auto-expire messages after a duration</li>
+                    <li>Refresh the page — persisted messages are recovered via <code>drain()</code></li>
+                </ul>
                 <pre style={{ marginTop: 8 }}>
-                    {`# Start Pulse with WAL queue persistence:
-PULSE_QUEUE_BACKEND=wal PULSE_QUEUE_WAL_DIR=./data pulse dev
+                    {`import { Pulse, PulseQueue } from '@sansavision/pulse-sdk'
+
+const conn = await new Pulse({ apiKey: 'dev' }).connect('ws://localhost:4001')
+const queue = new PulseQueue(conn, 'task-queue')
 
-# Or with PostgreSQL:
-PULSE_QUEUE_BACKEND=postgres PULSE_QUEUE_POSTGRES_URL=postgres://... pulse dev
+// Publish with TTL
+await queue.publish('hello world', { ttlSecs: 60 })
 
-# Or with Redis:
-PULSE_QUEUE_BACKEND=redis PULSE_QUEUE_REDIS_URL=redis://localhost:6379 pulse dev
+// Pull + Ack
+const msg = await queue.pull()
+if (msg) await queue.ack(msg.sequence)
 
-# Enable encryption at rest (any backend):
-PULSE_QUEUE_KEY=$(openssl rand -hex 32) pulse dev`}
+// Drain all pending (useful after reconnect)
+const recovered = await queue.drain()`}
                 </pre>
             </div>
         </div>

package/templates/react-watch-together/package.json

@@ -9,7 +9,7 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "@sansavision/pulse-sdk": "0.3.0",
+    "@sansavision/pulse-sdk": "^0.4.1",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "lucide-react": "^0.412.0"
@@ -24,4 +24,4 @@
     "typescript": "^5.5.3",
     "vite": "^5.3.4"
   }
-}
+}

package/templates/react-watch-together/src/App.tsx

@@ -38,7 +38,7 @@ export default function App() {
         }]);
     }, []);
 
-    const handleSyncMessage = useCallback((msg: any) => {
+    const handleSyncMessage = useCallback((msg: { action: string; time?: number; ts?: number; quality?: string }) => {
         // Calculate delivery delay if timestamp present
         if (msg.ts) {
             const delay = Date.now() - msg.ts;
@@ -65,7 +65,7 @@ export default function App() {
                 break;
             case 'quality':
                 if (msg.quality) {
-                    const q = QUALITY_OPTIONS.find((o: any) => o.value === msg.quality);
+                    const q = QUALITY_OPTIONS.find((o) => o.value === msg.quality);
                     if (q) setSelectedQuality(q);
                 }
                 break;
@@ -81,36 +81,19 @@ export default function App() {
         const msg = { action, time, ts: sendTs };
         broadcast(msg);
 
-        // Single-tab simulation: defer peerTime update by the measured relay
-        // round-trip so that drift is visible and realistic. In a real
-        // multi-tab setup the relay echo handler (handleSyncMessage) updates
-        // peerTime — but since the relay does not echo back to the sender,
-        // we simulate it here with the actual measured delay.
-        const simulatedDelay = delayHistoryRef.current.length > 0
-            ? delayHistoryRef.current[delayHistoryRef.current.length - 1]
-            : 4; // sensible default ~4ms first message
-
-        setTimeout(() => {
-            if (action === 'tick') {
-                setPeerTime(time);
-            } else if (action === 'play') {
-                setIsPlaying(true);
-                setPeerTime(time);
-            } else if (action === 'pause') {
-                setIsPlaying(false);
-                setPeerTime(time);
-            } else if (action === 'seek') {
-                setPeerTime(time);
-            }
-        }, simulatedDelay);
-
-        // Measure delay after the event loop processes the send (captures
-        // real serialization + WebSocket write time, not synchronous 0).
-        setTimeout(() => {
-            const delay = Date.now() - sendTs;
-            setLastDelay(delay);
-            delayHistoryRef.current = [...delayHistoryRef.current.slice(-29), delay];
-        }, 0);
+        // Single-tab simulation: update peerTime immediately (in a real
+        // multi-tab setup the relay echo handler updates peerTime).
+        if (action === 'tick') {
+            setPeerTime(time);
+        } else if (action === 'play') {
+            setIsPlaying(true);
+            setPeerTime(time);
+        } else if (action === 'pause') {
+            setIsPlaying(false);
+            setPeerTime(time);
+        } else if (action === 'seek') {
+            setPeerTime(time);
+        }
     }, [broadcast, logEvent]);
 
     const handleQualityChange = useCallback((quality: typeof QUALITY_OPTIONS[0]) => {
@@ -120,11 +103,6 @@ export default function App() {
         broadcast({ action: 'quality', quality: quality.value, ts: Date.now() });
     }, [broadcast, logEvent]);
 
-    // Compute average delay
-    const avgDelay = delayHistoryRef.current.length > 0
-        ? Math.round(delayHistoryRef.current.reduce((a: number, b: number) => a + b, 0) / delayHistoryRef.current.length)
-        : null;
-
     const drift = Math.abs(hostTime - peerTime);
     const driftColor = drift > 0.15 ? 'text-brandAmber' : 'text-brandEmerald';
 
@@ -193,7 +171,7 @@ export default function App() {
                                 </button>
                                 {showQualityMenu && (
                                     <div className="absolute right-0 top-full mt-1 z-50 glass-panel rounded-xl overflow-hidden shadow-2xl border border-pulseBorder min-w-[120px]">
-                                        {QUALITY_OPTIONS.map((q: any) => (
+                                        {QUALITY_OPTIONS.map((q) => (
                                             <button
                                                 key={q.value}
                                                 onClick={() => handleQualityChange(q)}
@@ -262,14 +240,14 @@ export default function App() {
                                 <div className="flex justify-between items-center p-3 rounded-lg bg-black/30 border border-pulseBorder">
                                     <span className="text-textMuted">Relay RTT</span>
                                     <span className="text-textMain font-semibold tracking-wider">
-                                        {metrics ? `${Math.round(metrics.rtt)}ms` : avgDelay !== null ? `~${avgDelay * 2}ms` : '—'}
+                                        {metrics ? `${Math.round(metrics.rtt)}ms` : '—'}
                                     </span>
                                 </div>
                                 <div className="flex justify-between items-center p-3 rounded-lg bg-black/30 border border-pulseBorder">
                                     <span className="text-textMuted">Msg Delay</span>
                                     <span className={`font-semibold tracking-wider ${lastDelay !== null && lastDelay > 50 ? 'text-brandAmber' : 'text-brandEmerald'}`}>
                                         {lastDelay !== null ? `${lastDelay}ms` : '—'}
-                                        {avgDelay !== null && <span className="text-textDim text-[10px] ml-1">avg {avgDelay}ms</span>}
+                                        <span className="text-textDim text-[10px] ml-1">(relay echo)</span>
                                     </span>
                                 </div>
                             </div>

package/src/index.ts

@@ -1,115 +0,0 @@
-#!/usr/bin/env node
-import * as p from '@clack/prompts';
-import pc from 'picocolors';
-import mri from 'mri';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const argv = mri(process.argv.slice(2));
-
-// In CommonJS, __dirname is available, but since we compile with tsup to CJS, we can just use __dirname.
-const TEMPLATES_DIR = path.join(__dirname, '../templates');
-
-async function main() {
-    p.intro(pc.bgMagenta(pc.white(' Create Pulse App ')));
-
-    let targetDir = argv._[0];
-
-    const project = await p.group(
-        {
-            path: () => {
-                if (targetDir) return Promise.resolve(targetDir);
-                return p.text({
-                    message: 'Project name:',
-                    initialValue: 'pulse-app',
-                    validate: (val) => {
-                        if (!val || val.trim() === '') return 'Project name is required';
-                        return;
-                    }
-                });
-            },
-            template: () => {
-                return p.select({
-                    message: 'Pick a template:',
-                    options: [
-                        { value: 'react-watch-together', label: 'Watch Together (React + TS)', hint: 'Synchronized video playback' },
-                        { value: 'react-all-features', label: 'All Features (React + TS)', hint: 'Chat, Video, Audio, RPC' },
-                        { value: 'react-queue-demo', label: 'Durable Queues (React + TS)', hint: 'Persistent queues with WAL/Postgres/Redis' },
-                        { value: 'vanilla-basic', label: 'Vanilla JS (Basic)', hint: 'Minimal setup' }
-                    ]
-                });
-            }
-        },
-        {
-            onCancel: () => {
-                p.cancel('Operation cancelled.');
-                process.exit(0);
-            }
-        }
-    );
-
-    const destDir = path.resolve(process.cwd(), project.path);
-    if (!fs.existsSync(destDir)) {
-        fs.mkdirSync(destDir, { recursive: true });
-    }
-
-    const s = p.spinner();
-    s.start(`Scaffolding project in ${pc.cyan(project.path)}...`);
-
-    const templateDir = path.join(TEMPLATES_DIR, project.template as string);
-
-    if (!fs.existsSync(templateDir)) {
-        s.stop(pc.red(`Template ${project.template} not found at ${templateDir}`));
-        process.exit(1);
-    }
-
-    copyDir(templateDir, destDir);
-
-    // Rename _gitignore to .gitignore
-    const gitignorePath = path.join(destDir, '_gitignore');
-    if (fs.existsSync(gitignorePath)) {
-        fs.renameSync(gitignorePath, path.join(destDir, '.gitignore'));
-    }
-
-    // Update package.json name to match the project path
-    const pkgPath = path.join(destDir, 'package.json');
-    if (fs.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-        pkg.name = path.basename(destDir);
-        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
-    }
-
-    s.stop(`Scaffolded ${pc.cyan(project.template)} template in ${pc.cyan(project.path)}`);
-
-    p.note(
-        `cd ${project.path}\n` +
-        `npm install\n` +
-        `npm run dev`,
-        'Next steps'
-    );
-
-    p.outro(pc.magenta('Pulse is ready! 🚀'));
-}
-
-function copyDir(src: string, dest: string) {
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-
-    for (const entry of entries) {
-        const srcPath = path.join(src, entry.name);
-        if (entry.name === 'node_modules' || entry.name === 'dist') continue;
-
-        const destPath = path.join(dest, entry.name);
-
-        if (entry.isDirectory()) {
-            if (!fs.existsSync(destPath)) {
-                fs.mkdirSync(destPath);
-            }
-            copyDir(srcPath, destPath);
-        } else {
-            fs.copyFileSync(srcPath, destPath);
-        }
-    }
-}
-
-main().catch(console.error);