lunel-cli 0.1.41 → 0.1.43

package/dist/index.js

@@ -13,6 +13,8 @@ import { createServer, createConnection } from "net";
 import { createInterface } from "readline";
 const DEFAULT_PROXY_URL = normalizeGatewayUrl(process.env.LUNEL_PROXY_URL || "https://gateway.lunel.dev");
 const MANAGER_URL = normalizeGatewayUrl(process.env.LUNEL_MANAGER_URL || "https://manager.lunel.dev");
+const CLOUD_JOB_CONFIG_PATH = "/etc/lunel/job.json";
+const VM_HEARTBEAT_INTERVAL_MS = 10_000;
 const CLI_ARGS = process.argv.slice(2);
 import { createRequire } from "module";
 const __require = createRequire(import.meta.url);
@@ -33,6 +35,8 @@ const processOutputBuffers = new Map();
 let lastCpuInfo = null;
 // OpenCode client
 let opencodeClient = null;
+// Tracks the most recently used OpenCode session ID so we can validate it after SSE reconnects.
+let lastActiveOpenCodeSessionId = null;
 // Proxy tunnel management
 let currentSessionCode = null;
 let currentSessionPassword = null;
@@ -44,6 +48,51 @@ let activeControlWs = null;
 let activeDataWs = null;
 const activeTunnels = new Map();
 const PORT_SYNC_INTERVAL_MS = 30_000;
+let cloudJobConfig = null;
+let vmHeartbeatTimer = null;
+async function readCloudJobConfig() {
+    try {
+        const data = await fs.readFile(CLOUD_JOB_CONFIG_PATH, "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+function startVmHeartbeat(resumeToken) {
+    if (!cloudJobConfig?.session_code)
+        return;
+    if (vmHeartbeatTimer)
+        return;
+    const cfg = cloudJobConfig;
+    const sendHeartbeat = () => {
+        if (shuttingDown)
+            return;
+        fetch(`${MANAGER_URL}/v1/vm/heartbeat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                sandboxId: cfg.sandbox_id,
+                resumeToken,
+                sandmanUrl: cfg.sandman_url || "",
+                repoUrl: cfg.repo_url,
+                branch: cfg.branch,
+                vmProfile: cfg.vm_profile || "",
+            }),
+        }).catch((err) => {
+            if (!shuttingDown)
+                console.warn("[vm] heartbeat failed:", err.message);
+        });
+    };
+    sendHeartbeat();
+    vmHeartbeatTimer = setInterval(sendHeartbeat, VM_HEARTBEAT_INTERVAL_MS);
+}
+function stopVmHeartbeat() {
+    if (vmHeartbeatTimer) {
+        clearInterval(vmHeartbeatTimer);
+        vmHeartbeatTimer = null;
+    }
+}
 const CLI_LOCAL_TCP_CONNECT_TIMEOUT_MS = 2_500;
 const PROXY_WS_CONNECT_TIMEOUT_MS = 12_000;
 const TUNNEL_SETUP_BUDGET_MS = 18_000;
@@ -781,6 +830,166 @@ async function handleGitDiscard(payload) {
 // Terminal Handlers (delegates to Rust PTY binary)
 // ============================================================================
 let dataChannel = null;
+let e2eeKeyPair = null;
+let e2eeCliToAppKey = null; // AES-256-GCM key, CLI→App direction
+let e2eeAppToCliKey = null; // AES-256-GCM key, App→CLI direction
+let e2eeActive = false;
+let e2eeSentReady = false;
+let e2eeGotReady = false;
+let e2eeOutboundCounter = 0;
+function e2eeReset() {
+    e2eeKeyPair = null;
+    e2eeCliToAppKey = null;
+    e2eeAppToCliKey = null;
+    e2eeActive = false;
+    e2eeSentReady = false;
+    e2eeGotReady = false;
+    e2eeOutboundCounter = 0;
+}
+function e2eeHandlePeerHello(peerPubkeyB64, dataWs) {
+    const kp = crypto.generateKeyPairSync("ec", { namedCurve: "P-256" });
+    e2eeKeyPair = kp;
+    const peerDer = Buffer.from(peerPubkeyB64, "base64url");
+    const peerPubKey = crypto.createPublicKey({ key: peerDer, type: "spki", format: "der" });
+    const sharedSecret = crypto.diffieHellman({ privateKey: kp.privateKey, publicKey: peerPubKey });
+    const salt = Buffer.alloc(32);
+    e2eeCliToAppKey = Buffer.from(crypto.hkdfSync("sha256", sharedSecret, salt, Buffer.from("lunel-cli-to-app"), 32));
+    e2eeAppToCliKey = Buffer.from(crypto.hkdfSync("sha256", sharedSecret, salt, Buffer.from("lunel-app-to-cli"), 32));
+    // Send our own pubkey so the app can derive the same shared secret
+    const mySpki = kp.publicKey.export({ type: "spki", format: "der" });
+    dataWs.send(JSON.stringify({ type: "e2ee_hello", pubkey: Buffer.from(mySpki).toString("base64url") }));
+    dataWs.send(JSON.stringify({ type: "e2ee_secure_ready" }));
+    e2eeSentReady = true;
+    if (e2eeGotReady) {
+        e2eeActive = true;
+        console.log("[e2ee] encryption active");
+    }
+}
+function e2eeHandlePeerReady() {
+    e2eeGotReady = true;
+    if (e2eeSentReady) {
+        e2eeActive = true;
+        console.log("[e2ee] encryption active");
+    }
+}
+function e2eeEncrypt(payload) {
+    if (!e2eeCliToAppKey)
+        throw new Error("[e2ee] CLI→App key not ready");
+    const nonce = Buffer.alloc(12);
+    nonce.writeUInt32BE(e2eeOutboundCounter++, 8);
+    const plain = Buffer.from(JSON.stringify(payload));
+    const cipher = crypto.createCipheriv("aes-256-gcm", e2eeCliToAppKey, nonce);
+    const ct = Buffer.concat([cipher.update(plain), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    // wire: nonce(12) || ct || tag(16) — consistent with WebCrypto AES-GCM format on app side
+    return Buffer.concat([nonce, ct, tag]).toString("base64url");
+}
+function e2eeDecrypt(enc) {
+    if (!e2eeAppToCliKey)
+        throw new Error("[e2ee] App→CLI key not ready");
+    const buf = Buffer.from(enc, "base64url");
+    const nonce = buf.subarray(0, 12);
+    const ct = buf.subarray(12, buf.length - 16);
+    const tag = buf.subarray(buf.length - 16);
+    const decipher = crypto.createDecipheriv("aes-256-gcm", e2eeAppToCliKey, nonce);
+    decipher.setAuthTag(tag);
+    return JSON.parse(Buffer.concat([decipher.update(ct), decipher.final()]).toString("utf-8"));
+}
+// ============================================================================
+// Replay buffer + backpressure
+// ============================================================================
+// Replay buffer for sequenced outbound data-channel messages
+let outboundSeq = 0;
+let lastSentSeq = 0; // highest seq actually flushed to the socket (not paused)
+const REPLAY_BUFFER_MAX_MESSAGES = 500;
+const REPLAY_BUFFER_MAX_BYTES = 10 * 1024 * 1024; // 10 MB
+const replayBuffer = [];
+let replayBufferBytes = 0;
+// Data-channel backpressure
+const DATA_CHANNEL_HIGH_WATER_BYTES = 1 * 1024 * 1024; // 1 MB — pause forwarding
+const DATA_CHANNEL_LOW_WATER_BYTES = 256 * 1024; // 256 KB — resume forwarding
+let dataChannelPaused = false;
+let dataChannelDrainTimer = null;
+function sendOnDataChannel(ws, msg) {
+    if (e2eeActive && e2eeCliToAppKey) {
+        const { payload, ...envelope } = msg;
+        ws.send(JSON.stringify({ ...envelope, enc: e2eeEncrypt(payload) }));
+    }
+    else {
+        ws.send(JSON.stringify(msg));
+    }
+}
+function sendSequenced(channel, msg) {
+    const seq = ++outboundSeq;
+    const msgWithSeq = { ...msg, seq };
+    const byteLen = Buffer.byteLength(JSON.stringify(msgWithSeq), "utf-8");
+    replayBuffer.push({ seq, msg: msgWithSeq, byteLen });
+    replayBufferBytes += byteLen;
+    while (replayBuffer.length > REPLAY_BUFFER_MAX_MESSAGES || replayBufferBytes > REPLAY_BUFFER_MAX_BYTES) {
+        const evicted = replayBuffer.shift();
+        if (evicted)
+            replayBufferBytes -= evicted.byteLen;
+    }
+    // Skip the actual send while backpressured — event is already in replay buffer
+    if (channel.readyState === WebSocket.OPEN && !dataChannelPaused) {
+        sendOnDataChannel(channel, msgWithSeq);
+        lastSentSeq = seq;
+    }
+}
+function resetReplayBuffer() {
+    outboundSeq = 0;
+    lastSentSeq = 0;
+    replayBuffer.length = 0;
+    replayBufferBytes = 0;
+    dataChannelPaused = false;
+    e2eeReset();
+    if (dataChannelDrainTimer) {
+        clearInterval(dataChannelDrainTimer);
+        dataChannelDrainTimer = null;
+    }
+}
+function resumeDataChannel() {
+    if (!dataChannelPaused)
+        return;
+    dataChannelPaused = false;
+    if (dataChannelDrainTimer) {
+        clearInterval(dataChannelDrainTimer);
+        dataChannelDrainTimer = null;
+    }
+    // Flush events that were buffered during the pause (re-encrypts with current key)
+    const toFlush = replayBuffer.filter((e) => e.seq > lastSentSeq);
+    if (dataChannel?.readyState === WebSocket.OPEN) {
+        for (const entry of toFlush) {
+            sendOnDataChannel(dataChannel, entry.msg);
+            lastSentSeq = entry.seq;
+        }
+    }
+    console.log(`[backpressure] data channel resumed, flushed ${toFlush.length} buffered events`);
+    if (activeControlWs?.readyState === WebSocket.OPEN) {
+        const buffered = dataChannel?.bufferedAmount ?? 0;
+        activeControlWs.send(JSON.stringify({ type: "data_channel_resumed", bufferedBytes: buffered }));
+    }
+}
+function checkDataChannelBackpressure() {
+    if (!dataChannel || dataChannel.readyState !== WebSocket.OPEN)
+        return;
+    const buffered = dataChannel.bufferedAmount ?? 0;
+    if (!dataChannelPaused && buffered > DATA_CHANNEL_HIGH_WATER_BYTES) {
+        dataChannelPaused = true;
+        console.warn(`[backpressure] data channel paused (${buffered} bytes buffered)`);
+        if (activeControlWs?.readyState === WebSocket.OPEN) {
+            activeControlWs.send(JSON.stringify({ type: "data_channel_paused", bufferedBytes: buffered }));
+        }
+        if (!dataChannelDrainTimer) {
+            dataChannelDrainTimer = setInterval(() => {
+                const current = dataChannel?.bufferedAmount ?? 0;
+                if (current < DATA_CHANNEL_LOW_WATER_BYTES || !dataChannel || dataChannel.readyState !== WebSocket.OPEN) {
+                    resumeDataChannel();
+                }
+            }, 100);
+        }
+    }
+}
 let ensurePtyBinaryPromise = null;
 function normalizeJsonWithTrailingCommas(text) {
     return text.replace(/,\s*([}\]])/g, "$1");
@@ -991,7 +1200,7 @@ async function ensurePtyProcess() {
                         scrollbackLength: event.scrollbackLength,
                     },
                 };
-                dataChannel.send(JSON.stringify(msg));
+                sendSequenced(dataChannel, msg);
             }
         }
         else if (event.event === "exit") {
@@ -1004,7 +1213,7 @@ async function ensurePtyProcess() {
                     action: "exit",
                     payload: { terminalId: event.id, code: event.code },
                 };
-                dataChannel.send(JSON.stringify(msg));
+                sendSequenced(dataChannel, msg);
             }
         }
         else if (event.event === "error") {
@@ -1155,7 +1364,7 @@ function handleProcessesSpawn(payload) {
                 action: "output",
                 payload: { pid, channel, stream, data: text },
             };
-            dataChannel.send(JSON.stringify(msg));
+            sendSequenced(dataChannel, msg);
         }
     };
     proc.stdout?.on("data", sendOutput("stdout"));
@@ -1634,6 +1843,8 @@ async function handleAiGetMessages(payload) {
 }
 async function handleAiPrompt(payload) {
     const sessionId = payload.sessionId;
+    if (sessionId)
+        lastActiveOpenCodeSessionId = sessionId;
     const text = payload.text;
     const model = payload.model;
     const agent = payload.agent;
@@ -1656,7 +1867,7 @@ async function handleAiPrompt(payload) {
     }).catch((err) => {
         console.error("[ai] prompt error:", err.message);
         if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
-            dataChannel.send(JSON.stringify({
+            sendSequenced(dataChannel, {
                 v: 1,
                 id: `evt-${Date.now()}`,
                 ns: "ai",
@@ -1665,7 +1876,7 @@ async function handleAiPrompt(payload) {
                     type: "prompt_error",
                     properties: { sessionId, error: err.message },
                 },
-            }));
+            });
         }
     });
     return { ack: true };
@@ -1765,43 +1976,99 @@ async function handleAiPermissionReply(payload) {
     return {};
 }
 // SSE event forwarding from OpenCode to mobile app
+const SSE_BACKOFF_INITIAL_MS = 500;
+const SSE_BACKOFF_CAP_MS = 30_000;
+const SSE_MAX_RETRIES = 20;
 async function subscribeToOpenCodeEvents(client) {
-    try {
-        const events = await client.event.subscribe();
-        for await (const raw of events.stream) {
-            // OpenCode SSE payload shapes vary across versions:
-            //   { type, properties, ... }
-            //   { payload: { type, properties, ... }, directory: "..." }
-            const parsed = raw;
-            const base = parsed?.payload && typeof parsed.payload === "object"
-                ? parsed.payload
-                : parsed;
-            if (!base || typeof base.type !== "string") {
-                console.warn("[sse] Dropped malformed event:", redactSensitive(JSON.stringify(parsed).substring(0, 200)));
-                continue;
+    let attempt = 0;
+    const backoffMs = (n) => {
+        const base = Math.min(SSE_BACKOFF_INITIAL_MS * 2 ** n, SSE_BACKOFF_CAP_MS);
+        const jitter = Math.random() * base * 0.3;
+        return Math.round(base + jitter);
+    };
+    while (!shuttingDown) {
+        try {
+            // On reconnect, verify the active OpenCode session is still alive.
+            // If OpenCode garbage-collected it, notify the app before resuming.
+            if (attempt > 0 && lastActiveOpenCodeSessionId) {
+                const checkResp = await client.session.get({ path: { id: lastActiveOpenCodeSessionId } });
+                if (checkResp.error) {
+                    console.warn(`[sse] OpenCode session ${lastActiveOpenCodeSessionId} was garbage-collected. Notifying app.`);
+                    const gcSessionId = lastActiveOpenCodeSessionId;
+                    lastActiveOpenCodeSessionId = null;
+                    if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
+                        sendSequenced(dataChannel, {
+                            v: 1,
+                            id: `evt-${Date.now()}`,
+                            ns: "ai",
+                            action: "event",
+                            payload: { type: "session_gc", properties: { sessionId: gcSessionId } },
+                        });
+                    }
+                }
+                else {
+                    console.log(`[sse] Active session ${lastActiveOpenCodeSessionId} still valid.`);
+                }
             }
-            console.log("[sse]", base.type);
-            if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
-                const msg = {
-                    v: 1,
-                    id: `evt-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`,
-                    ns: "ai",
-                    action: "event",
-                    payload: {
-                        type: base.type,
-                        properties: base.properties || {},
-                    },
-                };
-                dataChannel.send(JSON.stringify(msg));
+            const events = await client.event.subscribe();
+            if (attempt > 0) {
+                console.log(`[sse] reconnected after ${attempt} attempt(s)`);
             }
+            attempt = 0; // reset on successful connect
+            for await (const raw of events.stream) {
+                if (shuttingDown)
+                    return;
+                // OpenCode SSE payload shapes vary across versions:
+                //   { type, properties, ... }
+                //   { payload: { type, properties, ... }, directory: "..." }
+                const parsed = raw;
+                const base = parsed?.payload && typeof parsed.payload === "object"
+                    ? parsed.payload
+                    : parsed;
+                if (!base || typeof base.type !== "string") {
+                    console.warn("[sse] Dropped malformed event:", redactSensitive(JSON.stringify(parsed).substring(0, 200)));
+                    continue;
+                }
+                console.log("[sse]", base.type);
+                if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
+                    const msg = {
+                        v: 1,
+                        id: `evt-${Date.now()}`,
+                        ns: "ai",
+                        action: "event",
+                        payload: {
+                            type: base.type,
+                            properties: base.properties || {},
+                        },
+                    };
+                    sendSequenced(dataChannel, msg);
+                    checkDataChannelBackpressure();
+                }
+            }
+            // Stream ended normally — reconnect immediately (attempt stays 0 for normal end)
+            console.log("[sse] Event stream ended, reconnecting...");
+        }
+        catch (err) {
+            if (shuttingDown)
+                return;
+            attempt++;
+            const delay = backoffMs(attempt - 1);
+            console.error(`[sse] Stream error (attempt ${attempt}/${SSE_MAX_RETRIES}): ${err.message}. Retrying in ${delay}ms`);
+            if (attempt >= SSE_MAX_RETRIES) {
+                console.error("[sse] Max retries reached. Sending error event to app and giving up.");
+                if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
+                    sendSequenced(dataChannel, {
+                        v: 1,
+                        id: `evt-${Date.now()}`,
+                        ns: "ai",
+                        action: "event",
+                        payload: { type: "sse_dead", properties: { error: err.message, attempts: attempt } },
+                    });
+                }
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, delay));
         }
-        // Stream ended normally — reconnect
-        console.log("[sse] Event stream ended, reconnecting...");
-        setTimeout(() => subscribeToOpenCodeEvents(client), 1000);
-    }
-    catch (err) {
-        console.error("[sse] Event stream error:", err.message);
-        setTimeout(() => subscribeToOpenCodeEvents(client), 3000);
     }
 }
 // Proxy Handlers
@@ -2427,7 +2694,13 @@ async function processMessage(message) {
     }
 }
 function sendResponseOnData(response, dataWs) {
-    dataWs.send(JSON.stringify(response));
+    if (e2eeActive && e2eeCliToAppKey) {
+        const { payload, ...envelope } = response;
+        dataWs.send(JSON.stringify({ ...envelope, enc: e2eeEncrypt(payload) }));
+    }
+    else {
+        dataWs.send(JSON.stringify(response));
+    }
 }
 function normalizeGatewayUrl(input) {
     const raw = input.trim();
@@ -2461,6 +2734,13 @@ async function createSessionFromManager() {
     }
     return (await response.json());
 }
+async function connectToCloudSession(sessionCode) {
+    const response = await fetch(`${MANAGER_URL}/v1/session/${sessionCode}`);
+    if (!response.ok) {
+        throw new Error(`Failed to look up cloud session ${sessionCode}: ${response.status}`);
+    }
+    return (await response.json());
+}
 function displayQR(primaryGateway, backupGateway, code) {
     console.log("\n");
     qrcode.generate(code, { small: true }, (qr) => {
@@ -2498,6 +2778,7 @@ function buildWsUrl(gatewayUrl, role, channel) {
 function gracefulShutdown() {
     shuttingDown = true;
     console.log("\nShutting down...");
+    stopVmHeartbeat();
     stopPortSync();
     if (ptyProcess) {
         ptyProcess.kill();
@@ -2575,6 +2856,8 @@ async function connectWebSocket() {
                             if (message.type === "connected")
                                 return;
                             if (message.type === "session_password" && message.password) {
+                                if (!currentSessionPassword)
+                                    resetReplayBuffer(); // new session
                                 currentSessionPassword = message.password;
                                 console.log("[session] received reconnect password");
                                 return;
@@ -2640,9 +2923,41 @@ async function connectWebSocket() {
                 });
                 dataWs.on("message", async (data) => {
                     try {
-                        const message = JSON.parse(data.toString());
-                        if (message.type === "connected")
+                        const raw = JSON.parse(data.toString());
+                        if (raw.type === "connected")
+                            return;
+                        // E2EE handshake messages (always plaintext)
+                        if (raw.type === "e2ee_hello" && typeof raw.pubkey === "string") {
+                            e2eeHandlePeerHello(raw.pubkey, dataWs);
                             return;
+                        }
+                        if (raw.type === "e2ee_secure_ready") {
+                            e2eeHandlePeerReady();
+                            return;
+                        }
+                        // Reconnect request: reset E2EE so fresh handshake happens, then replay
+                        if (raw.ns === "system" && raw.action === "reconnect") {
+                            e2eeReset();
+                            const lastSeq = Number(raw.payload?.lastSeq ?? 0);
+                            const toReplay = replayBuffer.filter((e) => e.seq > lastSeq);
+                            console.log(`[replay] replaying ${toReplay.length} messages after seq ${lastSeq}`);
+                            // Replay without encryption — E2EE handshake hasn't completed yet
+                            for (const entry of toReplay)
+                                dataWs.send(JSON.stringify(entry.msg));
+                            return;
+                        }
+                        // Decrypt payload if E2EE is active
+                        let message = raw;
+                        if (e2eeActive && typeof raw.enc === "string") {
+                            try {
+                                message = { ...raw, payload: e2eeDecrypt(raw.enc) };
+                                delete message.enc;
+                            }
+                            catch (decErr) {
+                                console.error("[e2ee] decryption failed:", decErr.message);
+                                return;
+                            }
+                        }
                         if (isProtocolResponse(message)) {
                             // Ignore server/app responses forwarded over WS; CLI only processes requests.
                             return;
@@ -2659,6 +2974,12 @@ async function connectWebSocket() {
                     }
                 });
                 dataWs.on("close", (code, reason) => {
+                    // Reset backpressure state so reconnect starts fresh
+                    dataChannelPaused = false;
+                    if (dataChannelDrainTimer) {
+                        clearInterval(dataChannelDrainTimer);
+                        dataChannelDrainTimer = null;
+                    }
                     if (!settled) {
                         failConnection(`data close before ready (${code}: ${reason.toString()})`);
                         return;
@@ -2710,6 +3031,11 @@ async function main() {
     if (EXTRA_PORTS.length > 0) {
         console.log(`Extra ports enabled: ${EXTRA_PORTS.join(", ")}`);
     }
+    // Detect cloud VM mode
+    cloudJobConfig = await readCloudJobConfig();
+    if (cloudJobConfig?.session_code) {
+        console.log(`[cloud] Running in VM mode (sandbox: ${cloudJobConfig.sandbox_id})`);
+    }
     try {
         console.log("Checking PTY runtime...");
         await ensurePtyBinaryReady();
@@ -2740,13 +3066,26 @@ async function main() {
         console.log("OpenCode ready.\n");
         // Subscribe to OpenCode events
         subscribeToOpenCodeEvents(client);
-        const session = await createSessionFromManager();
+        let session;
+        if (cloudJobConfig?.session_code) {
+            // Cloud mode: connect to an existing session assigned by the manager
+            session = await connectToCloudSession(cloudJobConfig.session_code);
+            console.log(`[cloud] Connected to session ${session.code} via ${session.primary}`);
+        }
+        else {
+            // Public mode: create a new session and show QR code
+            session = await createSessionFromManager();
+            displayQR(normalizeGatewayUrl(session.primary), session.backup ? normalizeGatewayUrl(session.backup) : null, session.code);
+        }
         currentPrimaryGateway = normalizeGatewayUrl(session.primary);
         currentBackupGateway = session.backup ? normalizeGatewayUrl(session.backup) : null;
         currentSessionPassword = session.password;
         activeGatewayUrl = currentPrimaryGateway;
         currentSessionCode = session.code;
-        displayQR(currentPrimaryGateway, currentBackupGateway, session.code);
+        // Start VM heartbeat in cloud mode (session.password = resumeToken)
+        if (cloudJobConfig?.session_code) {
+            startVmHeartbeat(session.password);
+        }
         await connectWebSocket();
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "author": [
     {
       "name": "Soham Bharambe",
@@ -32,6 +32,7 @@
     "ws": "^8.18.0"
   },
   "devDependencies": {
+    "@types/minimatch": "^5.1.2",
     "@types/node": "^20.0.0",
     "@types/qrcode-terminal": "^0.12.2",
     "@types/ws": "^8.5.13",