lunel-cli 0.1.113 → 0.1.115

package/dist/ai/index.d.ts

@@ -1,4 +1,4 @@
-import type { AiEvent, ModelSelector, FileAttachment } from "./interface.js";
+import type { AiEvent, ModelSelector, FileAttachment, CodexPromptOptions } from "./interface.js";
 export type AiBackend = "opencode" | "codex";
 export declare class AiManager {
     private _providers;
@@ -23,10 +23,13 @@ export declare class AiManager {
     deleteSession(backend: AiBackend, id: string): Promise<{
         deleted: boolean;
     }>;
+    renameSession(backend: AiBackend, id: string, title: string): Promise<{
+        session: import("./interface.js").SessionInfo;
+    }>;
     getMessages(backend: AiBackend, sessionId: string): Promise<{
         messages: import("./interface.js").MessageInfo[];
     }>;
-    prompt(backend: AiBackend, sessionId: string, text: string, model?: ModelSelector, agent?: string, files?: FileAttachment[]): Promise<{
+    prompt(backend: AiBackend, sessionId: string, text: string, model?: ModelSelector, agent?: string, files?: FileAttachment[], codexOptions?: CodexPromptOptions): Promise<{
         ack: true;
     }>;
     abort(backend: AiBackend, sessionId: string): Promise<Record<string, never>>;

package/dist/ai/index.js

@@ -72,10 +72,11 @@ export class AiManager {
     createSession(backend, title) { return this.get(backend).createSession(title); }
     getSession(backend, id) { return this.get(backend).getSession(id); }
     deleteSession(backend, id) { return this.get(backend).deleteSession(id); }
+    renameSession(backend, id, title) { return this.get(backend).renameSession(id, title); }
     getMessages(backend, sessionId) { return this.get(backend).getMessages(sessionId); }
-    prompt(backend, sessionId, text, model, agent, files) {
+    prompt(backend, sessionId, text, model, agent, files, codexOptions) {
         this.get(backend).setActiveSession?.(sessionId);
-        return this.get(backend).prompt(sessionId, text, model, agent, files);
+        return this.get(backend).prompt(sessionId, text, model, agent, files, codexOptions);
     }
     abort(backend, sessionId) { return this.get(backend).abort(sessionId); }
     // Metadata — backend is optional, falls back to first available

package/dist/ai/interface.d.ts

@@ -7,6 +7,11 @@ export interface ModelSelector {
     providerID: string;
     modelID: string;
 }
+export interface CodexPromptOptions {
+    reasoningEffort?: "low" | "medium" | "high";
+    speed?: "fast" | "balanced" | "quality";
+    permissionMode?: "default" | "full-access";
+}
 export interface FileAttachment {
     type: "file";
     mime: string;
@@ -56,10 +61,13 @@ export interface AIProvider {
     deleteSession(id: string): Promise<{
         deleted: boolean;
     }>;
+    renameSession(id: string, title: string): Promise<{
+        session: SessionInfo;
+    }>;
     getMessages(sessionId: string): Promise<{
         messages: MessageInfo[];
     }>;
-    prompt(sessionId: string, text: string, model?: ModelSelector, agent?: string, files?: FileAttachment[]): Promise<{
+    prompt(sessionId: string, text: string, model?: ModelSelector, agent?: string, files?: FileAttachment[], codexOptions?: CodexPromptOptions): Promise<{
         ack: true;
     }>;
     abort(sessionId: string): Promise<Record<string, never>>;

package/dist/ai/opencode.d.ts

@@ -1,4 +1,4 @@
-import type { AIProvider, AiEventEmitter, FileAttachment, ModelSelector, MessageInfo, ProviderInfo, SessionInfo, ShareInfo } from "./interface.js";
+import type { AIProvider, AiEventEmitter, CodexPromptOptions, FileAttachment, ModelSelector, MessageInfo, ProviderInfo, SessionInfo, ShareInfo } from "./interface.js";
 export declare class OpenCodeProvider implements AIProvider {
     private client;
     private server;
@@ -24,10 +24,13 @@ export declare class OpenCodeProvider implements AIProvider {
     deleteSession(id: string): Promise<{
         deleted: boolean;
     }>;
+    renameSession(id: string, title: string): Promise<{
+        session: SessionInfo;
+    }>;
     getMessages(sessionId: string): Promise<{
         messages: MessageInfo[];
     }>;
-    prompt(sessionId: string, text: string, model?: ModelSelector, agent?: string, files?: FileAttachment[]): Promise<{
+    prompt(sessionId: string, text: string, model?: ModelSelector, agent?: string, files?: FileAttachment[], codexOptions?: CodexPromptOptions): Promise<{
         ack: true;
     }>;
     abort(sessionId: string): Promise<Record<string, never>>;
@@ -50,12 +53,13 @@ export declare class OpenCodeProvider implements AIProvider {
     private runSseLoop;
     private sendPromptAsync;
     private reconcileOpenCodeState;
+    private refreshBusySessionMessages;
     private refreshSessionsMetadata;
     private refreshPendingPermissions;
     private refreshPendingQuestions;
     private fetchOpenCodeJson;
     private refreshSessionStatuses;
     private trackPermissionEvent;
-    private asRecord;
     private readString;
+    private asRecord;
 }

package/dist/ai/opencode.js

@@ -23,6 +23,236 @@ function requireData(response, label) {
     }
     return response.data;
 }
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function normalizeToolOutput(output, metadata) {
+    const attachments = Array.isArray(metadata.attachments) ? metadata.attachments : [];
+    if (attachments.length === 0)
+        return output;
+    const attachmentLines = attachments
+        .map((entry) => {
+        const file = asRecord(entry);
+        const filename = readString(file.filename)
+            ?? readString(file.path)
+            ?? readString(file.url)
+            ?? "attachment";
+        return `- ${filename}`;
+    })
+        .filter((line) => line.trim().length > 0);
+    if (attachmentLines.length === 0)
+        return output;
+    if (!output.trim()) {
+        return `Attachments:\n${attachmentLines.join("\n")}`;
+    }
+    return `${output}\n\nAttachments:\n${attachmentLines.join("\n")}`;
+}
+function buildPatchSummary(part) {
+    const hash = readString(part.hash);
+    const files = Array.isArray(part.files)
+        ? part.files.map((value) => String(value)).filter((value) => value.trim().length > 0)
+        : [];
+    const lines = [];
+    if (hash)
+        lines.push(`Patch hash: ${hash}`);
+    if (files.length > 0) {
+        lines.push("Files:");
+        for (const file of files)
+            lines.push(`- ${file}`);
+    }
+    return lines.join("\n");
+}
+function normalizeOpenCodePart(part) {
+    const raw = asRecord(part);
+    const type = readString(raw.type);
+    if (!type)
+        return raw;
+    if (type === "tool") {
+        const tool = readString(raw.tool) ?? "tool";
+        const state = asRecord(raw.state);
+        const status = readString(state.status) ?? "running";
+        const metadata = asRecord(state.metadata ?? raw.metadata);
+        const normalized = {
+            ...raw,
+            type: "tool",
+            toolName: tool,
+            name: tool,
+            state: status,
+            input: asRecord(state.input),
+            metadata,
+        };
+        const title = readString(state.title);
+        if (title)
+            normalized.title = title;
+        const rawText = readString(state.raw);
+        if (rawText)
+            normalized.raw = rawText;
+        const time = asRecord(state.time);
+        if (Object.keys(time).length > 0) {
+            normalized.time = time;
+        }
+        if (status === "completed") {
+            const output = typeof state.output === "string" ? state.output : "";
+            normalized.output = normalizeToolOutput(output, {
+                ...metadata,
+                attachments: state.attachments,
+            });
+        }
+        else if (status === "error") {
+            normalized.error = readString(state.error) ?? "Tool failed";
+            const errorMessage = readString(state.error);
+            if (errorMessage)
+                normalized.output = errorMessage;
+        }
+        const attachments = Array.isArray(state.attachments) ? state.attachments : [];
+        if (attachments.length > 0) {
+            normalized.attachments = attachments.map((entry) => normalizeOpenCodePart(entry));
+        }
+        return normalized;
+    }
+    if (type === "step-start") {
+        const snapshot = readString(raw.snapshot);
+        return {
+            ...raw,
+            type: "step-start",
+            title: snapshot ? `Step started · ${snapshot}` : "Step started",
+        };
+    }
+    if (type === "step-finish") {
+        const reason = readString(raw.reason);
+        return {
+            ...raw,
+            type: "step-finish",
+            title: reason ? `Step finished · ${reason}` : "Step finished",
+        };
+    }
+    if (type === "patch") {
+        return {
+            ...raw,
+            type: "file-change",
+            title: "File changes",
+            output: buildPatchSummary(raw),
+        };
+    }
+    if (type === "subtask") {
+        return {
+            ...raw,
+            type: "tool",
+            toolName: "subtask",
+            name: "subtask",
+            state: "completed",
+            input: {
+                prompt: readString(raw.prompt) ?? "",
+                description: readString(raw.description) ?? "",
+                agent: readString(raw.agent) ?? "",
+                ...(readString(raw.command) ? { command: readString(raw.command) } : {}),
+            },
+            output: readString(raw.description) ?? readString(raw.prompt) ?? "Subtask requested",
+        };
+    }
+    if (type === "agent") {
+        const name = readString(raw.name) ?? "Agent";
+        return {
+            ...raw,
+            type: "step-start",
+            title: `Agent · ${name}`,
+        };
+    }
+    if (type === "retry") {
+        const attempt = raw.attempt;
+        const error = asRecord(raw.error);
+        const message = readString(error.message) ?? "Retry requested";
+        return {
+            ...raw,
+            type: "tool",
+            toolName: "retry",
+            name: "retry",
+            state: "error",
+            input: {
+                attempt,
+            },
+            error: message,
+            output: message,
+        };
+    }
+    if (type === "compaction") {
+        const auto = raw.auto === true;
+        const overflow = raw.overflow === true;
+        return {
+            ...raw,
+            type: "step-start",
+            title: `Context compacted${auto ? " · auto" : ""}${overflow ? " · overflow" : ""}`,
+        };
+    }
+    if (type === "snapshot") {
+        return {
+            ...raw,
+            type: "step-start",
+            title: "Workspace snapshot",
+        };
+    }
+    return raw;
+}
+function normalizeOpenCodeMessage(message) {
+    return {
+        id: message.info.id,
+        role: message.info.role,
+        parts: (message.parts || []).map((part) => normalizeOpenCodePart(part)),
+        time: message.info.time,
+    };
+}
+function normalizePermissionProperties(properties) {
+    const tool = asRecord(properties.tool);
+    const metadata = properties.metadata && typeof properties.metadata === "object"
+        ? properties.metadata
+        : properties;
+    return {
+        id: readString(properties.id),
+        sessionID: readString(properties.sessionID) ?? readString(properties.sessionId),
+        messageID: readString(properties.messageID) ?? readString(tool.messageID),
+        callID: readString(properties.callID) ?? readString(tool.callID),
+        type: readString(properties.type) ?? readString(properties.permission) ?? "permission",
+        title: readString(properties.title)
+            ?? readString(properties.permission)
+            ?? "Permission requested",
+        metadata,
+    };
+}
+function normalizeOpenCodeEvent(event) {
+    const { type, properties } = event;
+    if (type === "message.part.updated") {
+        return {
+            type,
+            properties: {
+                ...properties,
+                part: normalizeOpenCodePart(properties.part),
+            },
+        };
+    }
+    if (type === "permission.updated" || type === "permission.asked") {
+        return {
+            type: "permission.updated",
+            properties: normalizePermissionProperties(properties),
+        };
+    }
+    if (type === "permission.replied") {
+        return {
+            type: "permission.replied",
+            properties: {
+                sessionID: readString(properties.sessionID) ?? readString(properties.sessionId),
+                permissionId: readString(properties.permissionID)
+                    ?? readString(properties.requestID)
+                    ?? readString(properties.permissionId)
+                    ?? readString(properties.id),
+                response: readString(properties.response) ?? readString(properties.reply),
+            },
+        };
+    }
+    return event;
+}
 export class OpenCodeProvider {
     client = null;
     server = null;
@@ -111,7 +341,23 @@ export class OpenCodeProvider {
     }
     async deleteSession(id) {
         const response = await this.client.session.delete({ path: { id } });
-        return { deleted: Boolean(requireData(response, "session.delete")) };
+        const raw = response;
+        if (raw.error) {
+            const errMsg = typeof raw.error === "string"
+                ? raw.error
+                : JSON.stringify(raw.error);
+            throw new Error(errMsg);
+        }
+        // Treat any non-error delete response as success. Some SDK/runtime combos
+        // return inconsistent boolean payloads despite successful deletion.
+        return { deleted: true };
+    }
+    async renameSession(id, title) {
+        const response = await this.client.session.update({
+            path: { id },
+            body: { title },
+        });
+        return { session: requireData(response, "session.update") };
     }
     // -------------------------------------------------------------------------
     // Messages
@@ -122,12 +368,7 @@ export class OpenCodeProvider {
         try {
             const response = await this.client.session.messages({ path: { id: sessionId } });
             const raw = requireData(response, "session.messages");
-            const messages = raw.map((m) => ({
-                id: m.info.id,
-                role: m.info.role,
-                parts: m.parts || [],
-                time: m.info.time,
-            }));
+            const messages = raw.map((m) => normalizeOpenCodeMessage(m));
             if (VERBOSE_AI_LOGS)
                 console.log("[ai] getMessages returned", messages.length, "messages");
             return { messages };
@@ -140,7 +381,8 @@ export class OpenCodeProvider {
     // -------------------------------------------------------------------------
     // Interaction
     // -------------------------------------------------------------------------
-    async prompt(sessionId, text, model, agent, files = []) {
+    async prompt(sessionId, text, model, agent, files = [], codexOptions) {
+        void codexOptions;
         if (sessionId)
             this.lastActiveSessionId = sessionId;
         if (VERBOSE_AI_LOGS) {
@@ -313,10 +555,15 @@ export class OpenCodeProvider {
                     if (base.type !== "server.heartbeat") {
                         console.log("[sse]", base.type);
                     }
-                    this.trackPermissionEvent(base.type, base.properties || {});
-                    this.emitter?.({ type: base.type, properties: base.properties || {} });
+                    const normalizedEvent = normalizeOpenCodeEvent({
+                        type: base.type,
+                        properties: base.properties || {},
+                    });
+                    this.trackPermissionEvent(normalizedEvent.type, normalizedEvent.properties || {});
+                    this.emitter?.(normalizedEvent);
                 }
                 console.log("[sse] Event stream ended, reconnecting...");
+                attempt++;
             }
             catch (err) {
                 if (this.shuttingDown)
@@ -378,6 +625,55 @@ export class OpenCodeProvider {
             this.refreshPendingQuestions(),
             this.refreshSessionStatuses(),
         ]);
+        await this.refreshBusySessionMessages();
+    }
+    async refreshBusySessionMessages() {
+        const server = this.server;
+        const authHeader = this.authHeader;
+        if (!server || !authHeader)
+            return;
+        const statusUrl = new URL("/session/status", server.url);
+        const statusResp = await fetch(statusUrl, {
+            headers: { Authorization: authHeader, accept: "application/json" },
+        }).catch(() => null);
+        if (!statusResp?.ok)
+            return;
+        const payload = await statusResp.json().catch(() => null);
+        if (!payload || typeof payload !== "object")
+            return;
+        for (const [sessionId, status] of Object.entries(payload)) {
+            const statusObj = status;
+            const statusType = typeof statusObj?.type === "string" ? statusObj.type.toLowerCase() : "";
+            if (statusType !== "busy")
+                continue;
+            try {
+                const response = await this.client.session.messages({ path: { id: sessionId } });
+                const raw = Array.isArray(response.data) ? response.data : [];
+                for (const m of raw) {
+                    const msgObj = this.asRecord(m);
+                    const info = this.asRecord(msgObj.info);
+                    const parts = Array.isArray(msgObj.parts) ? msgObj.parts : [];
+                    const msgId = this.readString(info.id);
+                    if (!msgId)
+                        continue;
+                    this.emitter?.({ type: "message.updated", properties: { info } });
+                    for (const part of parts) {
+                        const partObj = normalizeOpenCodePart(part);
+                        this.emitter?.({
+                            type: "message.part.updated",
+                            properties: {
+                                part: { ...partObj, sessionID: sessionId, messageID: msgId },
+                                message: { sessionID: sessionId, id: msgId, role: info.role },
+                            },
+                        });
+                    }
+                }
+                console.log(`[sse] Re-synced messages for busy session ${sessionId} after reconnect`);
+            }
+            catch (err) {
+                console.warn(`[sse] Failed to refresh messages for busy session ${sessionId}:`, err.message);
+            }
+        }
     }
     async refreshSessionsMetadata() {
         const response = await this.client.session.list();
@@ -413,19 +709,7 @@ export class OpenCodeProvider {
             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,
-                },
+                properties: normalizePermissionProperties(permission),
             });
         }
         for (const id of Array.from(this.knownPendingPermissionIds)) {
@@ -529,40 +813,40 @@ export class OpenCodeProvider {
     }
     trackPermissionEvent(type, properties) {
         if (type === "permission.updated") {
-            const id = this.readString(properties.id);
+            const id = 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);
+            const id = readString(properties.permissionId)
+                ?? readString(properties.requestID)
+                ?? readString(properties.id);
             if (id) {
                 this.knownPendingPermissionIds.delete(id);
             }
         }
         if (type === "question.asked") {
-            const id = this.readString(properties.id);
+            const id = 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);
+            const id = readString(properties.requestID)
+                ?? readString(properties.questionId)
+                ?? 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;
+        return readString(value);
+    }
+    asRecord(value) {
+        return asRecord(value);
     }
 }