lunel-cli 0.1.114 → 0.1.116

package/dist/ai/index.d.ts

@@ -23,6 +23,9 @@ 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[];
     }>;

package/dist/ai/index.js

@@ -72,6 +72,7 @@ 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, codexOptions) {
         this.get(backend).setActiveSession?.(sessionId);

package/dist/ai/interface.d.ts

@@ -10,6 +10,7 @@ export interface ModelSelector {
 export interface CodexPromptOptions {
     reasoningEffort?: "low" | "medium" | "high";
     speed?: "fast" | "balanced" | "quality";
+    permissionMode?: "default" | "full-access";
 }
 export interface FileAttachment {
     type: "file";
@@ -60,6 +61,9 @@ export interface AIProvider {
     deleteSession(id: string): Promise<{
         deleted: boolean;
     }>;
+    renameSession(id: string, title: string): Promise<{
+        session: SessionInfo;
+    }>;
     getMessages(sessionId: string): Promise<{
         messages: MessageInfo[];
     }>;

package/dist/ai/opencode.d.ts

@@ -24,6 +24,9 @@ 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[];
     }>;
@@ -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 };
@@ -314,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)
@@ -379,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();
@@ -414,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)) {
@@ -530,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);
     }
 }

package/dist/index.js

@@ -31,6 +31,10 @@ const __require = createRequire(import.meta.url);
 const VERSION = __require("../package.json").version;
 const VERBOSE_AI_LOGS = process.env.LUNEL_DEBUG_AI === "1";
 const PTY_RELEASE_BASE_URL = "https://github.com/lunel-dev/lunel/releases/download/v0";
+const AI_RUNTIME_INSTALL_CANDIDATES = {
+    opencode: ["opencode-ai", "@opencode-ai/cli", "opencode"],
+    codex: ["@openai/codex", "codex"],
+};
 const PTY_RELEASES = {
     "linux:x64": {
         fileName: "lunel-pty-linux-x8664-0",
@@ -529,6 +533,34 @@ async function loadGitignore(dirPath) {
     }
     return ig;
 }
+const KNOWN_BINARY_EXTENSIONS = new Set([
+    ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".avif", ".ico", ".icns", ".heic", ".heif", ".tiff", ".tif",
+    ".psd", ".ai", ".eps",
+    ".mp3", ".wav", ".ogg", ".m4a", ".flac", ".aac",
+    ".mp4", ".mov", ".avi", ".mkv", ".webm", ".wmv", ".m4v",
+    ".pdf", ".zip", ".gz", ".tgz", ".bz2", ".xz", ".7z", ".rar", ".tar",
+    ".exe", ".dll", ".so", ".dylib", ".bin", ".class", ".o", ".obj", ".a", ".lib",
+    ".ttf", ".otf", ".woff", ".woff2", ".eot",
+]);
+function isLikelyBinaryContent(content) {
+    if (content.length === 0)
+        return false;
+    const sample = content.subarray(0, Math.min(content.length, 8192));
+    let suspicious = 0;
+    for (const byte of sample) {
+        if (byte === 0)
+            return true; // Null bytes strongly indicate binary data.
+        if (byte < 7 || (byte > 13 && byte < 32))
+            suspicious += 1;
+    }
+    return suspicious / sample.length > 0.3;
+}
+function shouldSkipAsBinary(filePath, content) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (KNOWN_BINARY_EXTENSIONS.has(ext))
+        return true;
+    return isLikelyBinaryContent(content);
+}
 async function handleFsGrep(payload) {
     const reqPath = payload.path || ".";
     const pattern = payload.pattern;
@@ -553,12 +585,12 @@ async function handleFsGrep(payload) {
             if (matches.length >= maxResults)
                 return;
             try {
-                const grepResult = shell.grep(regex, filePath);
-                if (grepResult.code !== 0 || !grepResult.stdout.trim()) {
+                const rawContent = await fs.readFile(filePath);
+                if (shouldSkipAsBinary(relativePath, rawContent)) {
                     regex.lastIndex = 0;
                     return;
                 }
-                const content = await fs.readFile(filePath, "utf-8");
+                const content = rawContent.toString("utf-8");
                 const lines = content.split("\n");
                 for (let i = 0; i < lines.length && matches.length < maxResults; i++) {
                     if (regex.test(lines[i])) {
@@ -927,9 +959,20 @@ async function handleGitDiscard(payload) {
         await runGit(["clean", "-fd"]);
     }
     else if (paths && paths.length > 0) {
-        const result = await runGit(["checkout", "--", ...paths]);
-        if (result.code !== 0) {
-            throw Object.assign(new Error(result.stderr || "git checkout failed"), { code: "EGIT" });
+        for (const filePath of paths) {
+            const tracked = await runGit(["ls-files", "--error-unmatch", "--", filePath]);
+            if (tracked.code === 0) {
+                const result = await runGit(["checkout", "--", filePath]);
+                if (result.code !== 0) {
+                    throw Object.assign(new Error(result.stderr || `git checkout failed for ${filePath}`), { code: "EGIT" });
+                }
+            }
+            else {
+                const cleanResult = await runGit(["clean", "-fd", "--", filePath]);
+                if (cleanResult.code !== 0) {
+                    throw Object.assign(new Error(cleanResult.stderr || `git clean failed for ${filePath}`), { code: "EGIT" });
+                }
+            }
         }
     }
     return {};
@@ -2631,6 +2674,9 @@ async function processMessage(message) {
                     case "deleteSession":
                         result = await aiManager.deleteSession(backend, payload.id);
                         break;
+                    case "renameSession":
+                        result = await aiManager.renameSession(backend, payload.id, payload.title);
+                        break;
                     case "getMessages":
                         result = await aiManager.getMessages(backend, payload.id);
                         break;
@@ -2945,6 +2991,78 @@ function displaySavedSessionNotice() {
     console.log(`${red}${border}${reset}`);
     console.log("");
 }
+function isCommandAvailable(command) {
+    const probe = spawnSync(command, ["--version"], {
+        stdio: "ignore",
+        shell: process.platform === "win32",
+    });
+    const err = probe.error;
+    if (err && (err.code === "ENOENT" || err.code === "ENOTDIR")) {
+        return false;
+    }
+    return !err;
+}
+function askYesNo(question, defaultValue = false) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const suffix = defaultValue ? " [Y/n] " : " [y/N] ";
+        rl.question(`${question}${suffix}`, (answer) => {
+            rl.close();
+            const normalized = answer.trim().toLowerCase();
+            if (!normalized) {
+                resolve(defaultValue);
+                return;
+            }
+            resolve(normalized === "y" || normalized === "yes");
+        });
+    });
+}
+function installLatestNpmPackage(pkg) {
+    const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+    const result = spawnSync(npmCommand, ["install", "-g", `${pkg}@latest`], {
+        stdio: "inherit",
+        shell: process.platform === "win32",
+        env: process.env,
+    });
+    return !result.error && result.status === 0;
+}
+async function ensureAiCliRuntimes() {
+    const missingBackends = Object.keys(AI_RUNTIME_INSTALL_CANDIDATES)
+        .filter((backend) => !isCommandAvailable(backend));
+    if (missingBackends.length === 0)
+        return;
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        console.warn(`[ai] Missing runtimes: ${missingBackends.join(", ")}. Run in an interactive shell to install them.`);
+        return;
+    }
+    const installPrompt = `Missing AI runtimes (${missingBackends.join(", ")}). Install latest versions now?`;
+    const approved = await askYesNo(installPrompt, false);
+    if (!approved) {
+        console.warn("[ai] Skipping AI runtime installation.");
+        return;
+    }
+    for (const backend of missingBackends) {
+        if (isCommandAvailable(backend))
+            continue;
+        const candidates = AI_RUNTIME_INSTALL_CANDIDATES[backend];
+        let installed = false;
+        for (const pkg of candidates) {
+            console.log(`[ai] Installing ${backend} via npm package ${pkg}@latest...`);
+            if (!installLatestNpmPackage(pkg))
+                continue;
+            if (isCommandAvailable(backend)) {
+                installed = true;
+                console.log(`[ai] ${backend} installed successfully.`);
+                break;
+            }
+        }
+        if (!installed) {
+            console.warn(`[ai] Failed to install ${backend}. You can install it manually and restart the CLI.`);
+        }
+    }
+}
 function gracefulShutdown() {
     shuttingDown = true;
     console.log("\nShutting down...");
@@ -3125,6 +3243,7 @@ async function main() {
         else {
             debugLog(`PTY runtime unsupported on ${os.platform()}/${os.arch()}. Skipping prefetch.\n`);
         }
+        await ensureAiCliRuntimes();
         // Start AI backends in the background so missing or slow AI runtimes never
         // block QR/session startup for the rest of the CLI.
         startAiManagerInBackground();

package/package.json

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