lunel-cli 0.1.57 → 0.1.59

package/dist/ai/codex.d.ts

@@ -43,6 +43,8 @@ export declare class CodexProvider implements AIProvider {
         share: ShareInfo;
     }>;
     permissionReply(sessionId: string, permissionId: string, response: "once" | "always" | "reject"): Promise<Record<string, never>>;
+    questionReply(): Promise<Record<string, never>>;
+    questionReject(): Promise<Record<string, never>>;
     private send;
     private call;
     private handleLine;

package/dist/ai/codex.js

@@ -209,6 +209,12 @@ export class CodexProvider {
         });
         return {};
     }
+    async questionReply() {
+        throw new Error("Codex structured user input is not supported by Lunel yet");
+    }
+    async questionReject() {
+        throw new Error("Codex structured user input is not supported by Lunel yet");
+    }
     send(req) {
         if (!this.proc?.stdin?.writable)
             return;

package/dist/ai/index.d.ts

@@ -42,6 +42,8 @@ export declare class AiManager {
         share: import("./interface.js").ShareInfo;
     }>;
     permissionReply(backend: AiBackend, sessionId: string, permissionId: string, response: "once" | "always" | "reject"): Promise<Record<string, never>>;
+    questionReply(backend: AiBackend, sessionId: string, questionId: string, answers: string[][]): Promise<Record<string, never>>;
+    questionReject(backend: AiBackend, sessionId: string, questionId: string): Promise<Record<string, never>>;
 }
 export declare function createAiManager(): Promise<AiManager>;
 export type { AIProvider, AiEventEmitter, AiEvent, ModelSelector } from "./interface.js";

package/dist/ai/index.js

@@ -84,6 +84,20 @@ export class AiManager {
     permissionReply(backend, sessionId, permissionId, response) {
         return this.get(backend).permissionReply(sessionId, permissionId, response);
     }
+    questionReply(backend, sessionId, questionId, answers) {
+        const provider = this.get(backend);
+        if (!provider.questionReply) {
+            throw new Error(`Backend "${backend}" does not support question replies`);
+        }
+        return provider.questionReply(sessionId, questionId, answers);
+    }
+    questionReject(backend, sessionId, questionId) {
+        const provider = this.get(backend);
+        if (!provider.questionReject) {
+            throw new Error(`Backend "${backend}" does not support question rejection`);
+        }
+        return provider.questionReject(sessionId, questionId);
+    }
 }
 export async function createAiManager() {
     const manager = new AiManager();

package/dist/ai/interface.d.ts

@@ -69,4 +69,6 @@ export interface AIProvider {
         share: ShareInfo;
     }>;
     permissionReply(sessionId: string, permissionId: string, response: "once" | "always" | "reject"): Promise<Record<string, never>>;
+    questionReply?(sessionId: string, questionId: string, answers: string[][]): Promise<Record<string, never>>;
+    questionReject?(sessionId: string, questionId: string): Promise<Record<string, never>>;
 }

package/dist/ai/opencode.d.ts

@@ -2,9 +2,12 @@ import type { AIProvider, AiEventEmitter, ModelSelector, MessageInfo, ProviderIn
 export declare class OpenCodeProvider implements AIProvider {
     private client;
     private server;
+    private authHeader;
     private lastActiveSessionId;
     private shuttingDown;
     private emitter;
+    private knownPendingPermissionIds;
+    private knownPendingQuestionIds;
     init(): Promise<void>;
     destroy(): Promise<void>;
     subscribe(emitter: AiEventEmitter): () => void;
@@ -40,5 +43,17 @@ export declare class OpenCodeProvider implements AIProvider {
         share: ShareInfo;
     }>;
     permissionReply(sessionId: string, permissionId: string, response: "once" | "always" | "reject"): Promise<Record<string, never>>;
+    questionReply(sessionId: string, questionId: string, answers: string[][]): Promise<Record<string, never>>;
+    questionReject(sessionId: string, questionId: string): Promise<Record<string, never>>;
     private runSseLoop;
+    private sendPromptAsync;
+    private reconcileOpenCodeState;
+    private refreshSessionsMetadata;
+    private refreshPendingPermissions;
+    private refreshPendingQuestions;
+    private fetchOpenCodeJson;
+    private refreshSessionStatuses;
+    private trackPermissionEvent;
+    private asRecord;
+    private readString;
 }

package/dist/ai/opencode.js

@@ -26,15 +26,19 @@ function requireData(response, label) {
 export class OpenCodeProvider {
     client = null;
     server = null;
+    authHeader = null;
     lastActiveSessionId = null;
     shuttingDown = false;
     emitter = null;
+    knownPendingPermissionIds = new Set();
+    knownPendingQuestionIds = new Set();
     async init() {
         const opencodeUsername = "lunel";
         const opencodePassword = crypto.randomBytes(32).toString("base64url");
         const authHeader = `Basic ${Buffer.from(`${opencodeUsername}:${opencodePassword}`).toString("base64")}`;
         process.env.OPENCODE_SERVER_USERNAME = opencodeUsername;
         process.env.OPENCODE_SERVER_PASSWORD = opencodePassword;
+        this.authHeader = authHeader;
         console.log("Starting OpenCode...");
         this.server = await createOpencodeServer({
             hostname: "127.0.0.1",
@@ -50,6 +54,7 @@ export class OpenCodeProvider {
     }
     async destroy() {
         this.shuttingDown = true;
+        this.authHeader = null;
     }
     subscribe(emitter) {
         this.emitter = emitter;
@@ -146,14 +151,9 @@ export class OpenCodeProvider {
             });
         }
         // Fire-and-forget — results come back through the SSE event stream.
-        this.client.session.prompt({
-            path: { id: sessionId },
-            body: {
-                parts: [{ type: "text", text }],
-                ...(model ? { model } : {}),
-                ...(agent ? { agent } : {}),
-            },
-        }).catch((err) => {
+        // Prefer the async prompt endpoint so long-running turns do not get tied
+        // to the request lifecycle the way the basic prompt route can be.
+        this.sendPromptAsync(sessionId, text, model, agent).catch((err) => {
             console.error("[ai] prompt error:", err.message);
             this.emitter?.({
                 type: "prompt_error",
@@ -243,6 +243,23 @@ export class OpenCodeProvider {
         });
         return {};
     }
+    async questionReply(sessionId, questionId, answers) {
+        await this.fetchOpenCodeJson(`/question/${encodeURIComponent(questionId)}/reply`, {
+            method: "POST",
+            body: { answers },
+        });
+        this.knownPendingQuestionIds.delete(questionId);
+        this.emitter?.({ type: "question.replied", properties: { sessionID: sessionId, requestID: questionId, answers } });
+        return {};
+    }
+    async questionReject(sessionId, questionId) {
+        await this.fetchOpenCodeJson(`/question/${encodeURIComponent(questionId)}/reject`, {
+            method: "POST",
+        });
+        this.knownPendingQuestionIds.delete(questionId);
+        this.emitter?.({ type: "question.rejected", properties: { sessionID: sessionId, requestID: questionId } });
+        return {};
+    }
     // -------------------------------------------------------------------------
     // SSE event loop (private)
     // -------------------------------------------------------------------------
@@ -270,6 +287,9 @@ export class OpenCodeProvider {
                         console.log(`[sse] Active session ${this.lastActiveSessionId} still valid.`);
                     }
                 }
+                if (attempt > 0) {
+                    await this.reconcileOpenCodeState();
+                }
                 const events = await this.client.event.subscribe();
                 if (attempt > 0) {
                     console.log(`[sse] reconnected after ${attempt} attempt(s)`);
@@ -290,6 +310,7 @@ export class OpenCodeProvider {
                         continue;
                     }
                     console.log("[sse]", base.type);
+                    this.trackPermissionEvent(base.type, base.properties || {});
                     this.emitter?.({ type: base.type, properties: base.properties || {} });
                 }
                 console.log("[sse] Event stream ended, reconnecting...");
@@ -312,4 +333,230 @@ export class OpenCodeProvider {
             }
         }
     }
+    async sendPromptAsync(sessionId, text, model, agent) {
+        const server = this.server;
+        const authHeader = this.authHeader;
+        if (!server || !authHeader) {
+            throw new Error("OpenCode server is not ready");
+        }
+        const url = new URL(`/session/${encodeURIComponent(sessionId)}/prompt_async`, server.url);
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: authHeader,
+                "content-type": "application/json",
+                accept: "application/json",
+            },
+            body: JSON.stringify({
+                parts: [{ type: "text", text }],
+                ...(model ? { model } : {}),
+                ...(agent ? { agent } : {}),
+            }),
+        });
+        if (!response.ok) {
+            let detail = "";
+            try {
+                detail = await response.text();
+            }
+            catch {
+                // ignore detail read failures
+            }
+            const suffix = detail.trim().length > 0 ? `: ${detail.trim()}` : "";
+            throw new Error(`OpenCode prompt_async failed (${response.status})${suffix}`);
+        }
+    }
+    async reconcileOpenCodeState() {
+        await Promise.allSettled([
+            this.refreshSessionsMetadata(),
+            this.refreshPendingPermissions(),
+            this.refreshPendingQuestions(),
+            this.refreshSessionStatuses(),
+        ]);
+    }
+    async refreshSessionsMetadata() {
+        const response = await this.client.session.list();
+        const sessions = Array.isArray(response.data) ? response.data : [];
+        for (const session of sessions) {
+            const info = this.asRecord(session);
+            const id = this.readString(info.id);
+            if (!id)
+                continue;
+            this.emitter?.({
+                type: "session.updated",
+                properties: { info },
+            });
+        }
+    }
+    async refreshPendingPermissions() {
+        const permissionApi = this.client?.permission;
+        if (!permissionApi?.list) {
+            return;
+        }
+        const response = await permissionApi.list();
+        const data = Array.isArray(response.data) ? response.data : [];
+        const nextIds = new Set();
+        for (const entry of data) {
+            const permission = this.asRecord(entry);
+            const id = this.readString(permission.id);
+            if (!id)
+                continue;
+            nextIds.add(id);
+            if (this.knownPendingPermissionIds.has(id)) {
+                continue;
+            }
+            this.knownPendingPermissionIds.add(id);
+            this.emitter?.({
+                type: "permission.updated",
+                properties: {
+                    id,
+                    sessionID: this.readString(permission.sessionID) ?? this.readString(permission.sessionId),
+                    messageID: this.readString(this.asRecord(permission.tool).messageID),
+                    callID: this.readString(this.asRecord(permission.tool).callID),
+                    type: this.readString(permission.permission) ?? "permission",
+                    title: this.readString(permission.title)
+                        ?? this.readString(permission.permission)
+                        ?? "Permission requested",
+                    metadata: permission.metadata && typeof permission.metadata === "object"
+                        ? permission.metadata
+                        : permission,
+                },
+            });
+        }
+        for (const id of Array.from(this.knownPendingPermissionIds)) {
+            if (nextIds.has(id))
+                continue;
+            this.knownPendingPermissionIds.delete(id);
+            this.emitter?.({ type: "permission.replied", properties: { permissionId: id } });
+        }
+    }
+    async refreshPendingQuestions() {
+        const data = await this.fetchOpenCodeJson("/question", {
+            method: "GET",
+        });
+        const questions = Array.isArray(data) ? data : [];
+        const nextIds = new Set();
+        for (const entry of questions) {
+            const question = this.asRecord(entry);
+            const id = this.readString(question.id);
+            const sessionID = this.readString(question.sessionID) ?? this.readString(question.sessionId);
+            if (!id || !sessionID)
+                continue;
+            nextIds.add(id);
+            if (this.knownPendingQuestionIds.has(id)) {
+                continue;
+            }
+            this.knownPendingQuestionIds.add(id);
+            this.emitter?.({
+                type: "question.asked",
+                properties: {
+                    id,
+                    sessionID,
+                    questions: Array.isArray(question.questions) ? question.questions : [],
+                    tool: typeof question.tool === "object" && question.tool !== null ? question.tool : undefined,
+                },
+            });
+        }
+        for (const id of Array.from(this.knownPendingQuestionIds)) {
+            if (nextIds.has(id))
+                continue;
+            this.knownPendingQuestionIds.delete(id);
+        }
+    }
+    async fetchOpenCodeJson(pathname, options = {}) {
+        const server = this.server;
+        const authHeader = this.authHeader;
+        if (!server || !authHeader) {
+            throw new Error("OpenCode server is not ready");
+        }
+        const url = new URL(pathname, server.url);
+        const response = await fetch(url, {
+            method: options.method ?? "GET",
+            headers: {
+                Authorization: authHeader,
+                accept: "application/json",
+                ...(options.body ? { "content-type": "application/json" } : {}),
+            },
+            ...(options.body ? { body: JSON.stringify(options.body) } : {}),
+        });
+        if (!response.ok) {
+            let detail = "";
+            try {
+                detail = await response.text();
+            }
+            catch {
+                // ignore detail read failures
+            }
+            const suffix = detail.trim().length > 0 ? `: ${detail.trim()}` : "";
+            throw new Error(`OpenCode request failed (${response.status})${suffix}`);
+        }
+        return response.json().catch(() => null);
+    }
+    async refreshSessionStatuses() {
+        const server = this.server;
+        const authHeader = this.authHeader;
+        if (!server || !authHeader) {
+            return;
+        }
+        const url = new URL("/session/status", server.url);
+        const response = await fetch(url, {
+            headers: {
+                Authorization: authHeader,
+                accept: "application/json",
+            },
+        });
+        if (!response.ok) {
+            return;
+        }
+        const payload = await response.json().catch(() => null);
+        if (!payload || typeof payload !== "object") {
+            return;
+        }
+        for (const [sessionId, status] of Object.entries(payload)) {
+            this.emitter?.({
+                type: "session.status",
+                properties: {
+                    sessionID: sessionId,
+                    status: status,
+                },
+            });
+        }
+    }
+    trackPermissionEvent(type, properties) {
+        if (type === "permission.updated") {
+            const id = this.readString(properties.id);
+            if (id) {
+                this.knownPendingPermissionIds.add(id);
+            }
+            return;
+        }
+        if (type === "permission.replied") {
+            const id = this.readString(properties.permissionId)
+                ?? this.readString(properties.requestID)
+                ?? this.readString(properties.id);
+            if (id) {
+                this.knownPendingPermissionIds.delete(id);
+            }
+        }
+        if (type === "question.asked") {
+            const id = this.readString(properties.id);
+            if (id) {
+                this.knownPendingQuestionIds.add(id);
+            }
+            return;
+        }
+        if (type === "question.replied" || type === "question.rejected") {
+            const id = this.readString(properties.requestID)
+                ?? this.readString(properties.questionId)
+                ?? this.readString(properties.id);
+            if (id) {
+                this.knownPendingQuestionIds.delete(id);
+            }
+        }
+    }
+    asRecord(value) {
+        return value && typeof value === "object" ? value : {};
+    }
+    readString(value) {
+        return typeof value === "string" && value.length > 0 ? value : undefined;
+    }
 }

package/dist/index.js

@@ -2410,6 +2410,12 @@ async function processMessage(message) {
                         result = await aiManager.permissionReply(backend, payload.sessionId, payload.permissionId, permResp);
                         break;
                     }
+                    case "questionReply":
+                        result = await aiManager.questionReply(backend, payload.sessionId, payload.questionId, payload.answers || []);
+                        break;
+                    case "questionReject":
+                        result = await aiManager.questionReject(backend, payload.sessionId, payload.questionId);
+                        break;
                     default:
                         throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
                 }

package/package.json

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