lunel-cli 0.1.23 → 0.1.27

package/dist/index.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import { WebSocket } from "ws";
 import qrcode from "qrcode-terminal";
-import { createOpencode } from "@opencode-ai/sdk";
+import { createOpencodeServer, createOpencodeClient } from "@opencode-ai/sdk";
+import * as crypto from "crypto";
 import Ignore from "ignore";
 const ignore = Ignore.default;
 import * as fs from "fs/promises";
@@ -1176,18 +1177,36 @@ function requireData(response, label) {
         const errMsg = response.error
             ? (typeof response.error === "string" ? response.error : JSON.stringify(response.error))
             : `${label} returned no data`;
+        console.error(`[ai] ${label} failed:`, errMsg, "raw response:", JSON.stringify(response).substring(0, 500));
         throw new Error(errMsg);
     }
     return response.data;
 }
 async function handleAiCreateSession(payload) {
     const title = payload.title || undefined;
-    const response = await opencodeClient.session.create({ body: { title } });
-    return { session: requireData(response, "session.create") };
+    console.log("[ai] createSession called, title:", title);
+    try {
+        const response = await opencodeClient.session.create({ body: { title } });
+        console.log("[ai] createSession response ok:", !!response.data, "error:", response.error ? JSON.stringify(response.error).substring(0, 200) : "none");
+        return { session: requireData(response, "session.create") };
+    }
+    catch (err) {
+        console.error("[ai] createSession exception:", err.message, err.stack);
+        throw err;
+    }
 }
 async function handleAiListSessions() {
-    const response = await opencodeClient.session.list();
-    return { sessions: requireData(response, "session.list") };
+    console.log("[ai] listSessions called");
+    try {
+        const response = await opencodeClient.session.list();
+        const data = requireData(response, "session.list");
+        console.log("[ai] listSessions returned", Array.isArray(data) ? data.length : typeof data, "sessions");
+        return { sessions: data };
+    }
+    catch (err) {
+        console.error("[ai] listSessions exception:", err.message);
+        throw err;
+    }
 }
 async function handleAiGetSession(payload) {
     const id = payload.id;
@@ -1203,14 +1222,22 @@ async function handleAiDeleteSession(payload) {
 }
 async function handleAiGetMessages(payload) {
     const id = payload.id;
-    const response = await opencodeClient.session.messages({ path: { id } });
-    return { messages: requireData(response, "session.messages") };
+    console.log("[ai] getMessages called, sessionId:", id);
+    try {
+        const response = await opencodeClient.session.messages({ path: { id } });
+        return { messages: requireData(response, "session.messages") };
+    }
+    catch (err) {
+        console.error("[ai] getMessages exception:", err.message);
+        throw err;
+    }
 }
 async function handleAiPrompt(payload) {
     const sessionId = payload.sessionId;
     const text = payload.text;
     const model = payload.model;
     const agent = payload.agent;
+    console.log("[ai] prompt called, sessionId:", sessionId, "model:", JSON.stringify(model), "agent:", agent, "text:", text.substring(0, 100));
     // Fire and forget — results stream via SSE events forwarded on data channel
     opencodeClient.session.prompt({
         path: { id: sessionId },
@@ -1220,6 +1247,7 @@ async function handleAiPrompt(payload) {
             ...(agent ? { agent } : {}),
         },
     }).catch((err) => {
+        console.error("[ai] prompt error:", err.message);
         if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
             dataChannel.send(JSON.stringify({
                 v: 1,
@@ -1241,13 +1269,30 @@ async function handleAiAbort(payload) {
     return {};
 }
 async function handleAiAgents() {
-    const response = await opencodeClient.app.agents();
-    return { agents: requireData(response, "app.agents") };
+    console.log("[ai] getAgents called");
+    try {
+        const response = await opencodeClient.app.agents();
+        const data = requireData(response, "app.agents");
+        console.log("[ai] getAgents returned:", JSON.stringify(data).substring(0, 300));
+        return { agents: data };
+    }
+    catch (err) {
+        console.error("[ai] getAgents exception:", err.message);
+        throw err;
+    }
 }
 async function handleAiProviders() {
-    const response = await opencodeClient.config.providers();
-    const data = requireData(response, "config.providers");
-    return { providers: data.providers, default: data.default };
+    console.log("[ai] getProviders called");
+    try {
+        const response = await opencodeClient.config.providers();
+        const data = requireData(response, "config.providers");
+        console.log("[ai] getProviders returned", data.providers?.length, "providers, defaults:", JSON.stringify(data.default));
+        return { providers: data.providers, default: data.default };
+    }
+    catch (err) {
+        console.error("[ai] getProviders exception:", err.message);
+        throw err;
+    }
 }
 async function handleAiSetAuth(payload) {
     const providerId = payload.providerId;
@@ -1310,7 +1355,19 @@ async function handleAiPermissionReply(payload) {
 async function subscribeToOpenCodeEvents(client) {
     try {
         const events = await client.event.subscribe();
-        for await (const event of events.stream) {
+        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:", JSON.stringify(parsed).substring(0, 200));
+                continue;
+            }
+            console.log("[sse]", base.type);
             if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
                 const msg = {
                     v: 1,
@@ -1318,16 +1375,19 @@ async function subscribeToOpenCodeEvents(client) {
                     ns: "ai",
                     action: "event",
                     payload: {
-                        type: event.type,
-                        properties: event.properties,
+                        type: base.type,
+                        properties: base.properties || {},
                     },
                 };
                 dataChannel.send(JSON.stringify(msg));
             }
         }
+        // Stream ended normally — reconnect
+        console.log("[sse] Event stream ended, reconnecting...");
+        setTimeout(() => subscribeToOpenCodeEvents(client), 1000);
     }
     catch (err) {
-        console.error("OpenCode event stream error:", err);
+        console.error("[sse] Event stream error:", err.message);
         setTimeout(() => subscribeToOpenCodeEvents(client), 3000);
     }
 }
@@ -1710,6 +1770,7 @@ async function processMessage(message) {
     }
     catch (error) {
         const err = error;
+        console.error(`[router] ${ns}.${action} error:`, err.code || "ERROR", err.message);
         return {
             v: 1,
             id,
@@ -1879,9 +1940,28 @@ async function main() {
     console.log("Lunel CLI v" + VERSION);
     console.log("=".repeat(20) + "\n");
     try {
-        // Start OpenCode server + client
+        // Generate auth credentials (like CodeNomad does)
+        const opencodeUsername = "lunel";
+        const opencodePassword = crypto.randomBytes(32).toString("base64url");
+        const authHeader = `Basic ${Buffer.from(`${opencodeUsername}:${opencodePassword}`).toString("base64")}`;
+        // Set auth env vars BEFORE spawning opencode
+        process.env.OPENCODE_SERVER_USERNAME = opencodeUsername;
+        process.env.OPENCODE_SERVER_PASSWORD = opencodePassword;
+        // Start OpenCode server with random port (like CodeNomad: --port 0)
         console.log("Starting OpenCode...");
-        const { client } = await createOpencode();
+        const server = await createOpencodeServer({
+            hostname: "127.0.0.1",
+            port: 0,
+            timeout: 15000,
+        });
+        console.log(`OpenCode server listening on ${server.url}`);
+        // Create client with auth headers
+        const client = createOpencodeClient({
+            baseUrl: server.url,
+            headers: {
+                "Authorization": authHeader,
+            },
+        });
         opencodeClient = client;
         console.log("OpenCode ready.\n");
         // Subscribe to OpenCode events
@@ -1893,6 +1973,8 @@ async function main() {
     catch (error) {
         if (error instanceof Error) {
             console.error(`Error: ${error.message}`);
+            if (error.stack)
+                console.error(error.stack);
         }
         else {
             console.error("An unexpected error occurred");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.23",
+  "version": "0.1.27",
   "author": [
     {
       "name": "Soham Bharambe",