lunel-cli 0.1.53 → 0.1.55

package/dist/ai/codex.d.ts

@@ -58,10 +58,14 @@ export declare class CodexProvider implements AIProvider {
     private ensureAssistantMessage;
     private upsertLocalMessagePart;
     private fetchServerThreads;
+    private refreshSessionMetadata;
+    private fetchServerThreadsByArchiveState;
     private fetchModels;
     private parseThreadListEntry;
     private hasNextCursor;
     private ingestThreadMetadata;
+    private reconcileSessionsWithServer;
+    private mergeSession;
     private upsertSession;
     private ensureLocalSession;
     private resolveSessionFromPayload;
@@ -87,6 +91,7 @@ export declare class CodexProvider implements AIProvider {
     private extractUpdatedAt;
     private readTimestamp;
     private firstString;
+    private firstStringFromSources;
     private readArray;
     private readString;
     private asRecord;
@@ -102,7 +107,9 @@ export declare class CodexProvider implements AIProvider {
     private renderFileChangeEntriesBody;
     private renderUnifiedDiffBody;
     private extractCanonicalPatch;
+    private normalizeDisplayPath;
     private normalizedFileChangeStatus;
     private extractToolInput;
+    private extractCommandExecutionInput;
     private describeCompletedItemOutput;
 }

package/dist/ai/codex.js

@@ -2,6 +2,7 @@
 // over stdin/stdout. Maps Codex's thread/turn model onto Lunel's AIProvider
 // contract using the same thread/list + thread/read flow used by Remodex.
 import * as crypto from "crypto";
+import * as path from "path";
 import { spawn } from "child_process";
 import { createInterface } from "readline";
 const THREAD_LIST_SOURCE_KINDS = ["cli", "vscode", "appServer", "exec", "unknown"];
@@ -61,14 +62,20 @@ export class CodexProvider {
             title: threadTitle,
             createdAt: this.extractCreatedAt(result) ?? Date.now(),
             updatedAt: this.extractUpdatedAt(result) ?? Date.now(),
+            archived: false,
         });
         return { session: this.toSessionInfo(session) };
     }
     async listSessions() {
-        const remoteThreads = await this.fetchServerThreads();
-        for (const thread of remoteThreads) {
-            this.upsertSession(thread);
+        const activeThreads = await this.fetchServerThreads();
+        let archivedThreads = [];
+        try {
+            archivedThreads = await this.fetchServerThreadsByArchiveState(true);
+        }
+        catch {
+            // Some Codex runtimes may not support archived thread listing.
         }
+        this.reconcileSessionsWithServer(activeThreads, archivedThreads);
         const sessions = Array.from(this.sessions.values())
             .sort((a, b) => a.updatedAt - b.updatedAt)
             .map((session) => this.toSessionInfo(session));
@@ -103,12 +110,14 @@ export class CodexProvider {
         const historyMessages = this.decodeMessagesFromThreadRead(sessionId, threadObject);
         if (historyMessages.length > 0) {
             session.messages = historyMessages;
-            session.updatedAt = this.extractUpdatedAt(threadObject) ?? session.updatedAt;
-            session.createdAt = this.extractCreatedAt(threadObject) ?? session.createdAt;
-            const title = this.extractThreadTitle(threadObject);
-            if (title)
-                session.title = title;
         }
+        this.upsertSession({
+            id: sessionId,
+            title: this.extractThreadTitle(threadObject),
+            createdAt: this.extractCreatedAt(threadObject) ?? session.createdAt,
+            updatedAt: this.extractUpdatedAt(threadObject) ?? session.updatedAt,
+            archived: false,
+        });
         return { messages: session.messages };
     }
     async prompt(sessionId, text, model, agent) {
@@ -297,15 +306,24 @@ export class CodexProvider {
             case "thread/started":
             case "thread/name/updated":
                 if (session) {
-                    const title = this.extractThreadTitle(params);
-                    if (title)
-                        session.title = title;
-                    session.updatedAt = this.extractUpdatedAt(params) ?? Date.now();
-                    this.emitter?.({ type: "session.updated", properties: { info: this.toSessionInfo(session) } });
+                    this.upsertSession({
+                        id: session.id,
+                        title: this.extractThreadTitle(params),
+                        createdAt: this.extractCreatedAt(params) ?? session.createdAt,
+                        updatedAt: this.extractUpdatedAt(params) ?? Date.now(),
+                        archived: false,
+                    }, true);
                 }
                 return;
             case "thread/status/changed":
                 if (session) {
+                    this.upsertSession({
+                        id: session.id,
+                        title: this.extractThreadTitle(params),
+                        createdAt: this.extractCreatedAt(params) ?? session.createdAt,
+                        updatedAt: this.extractUpdatedAt(params) ?? Date.now(),
+                        archived: session.archived,
+                    }, true);
                     this.emitter?.({
                         type: "session.status",
                         properties: { sessionID: session.id, status: params.status ?? params },
@@ -330,6 +348,9 @@ export class CodexProvider {
                     session.activeTurnId = undefined;
                     session.updatedAt = Date.now();
                     this.finishAssistantTurn(session, params, method === "turn/failed");
+                    this.refreshSessionMetadata(session.id).catch(() => {
+                        // Best-effort metadata refresh for title/preview updates after a turn ends.
+                    });
                     this.emitter?.({ type: "session.idle", properties: { sessionID: session.id } });
                     if (method === "turn/failed") {
                         const error = this.readString(this.asRecord(params.error).message) ?? "Turn failed";
@@ -605,12 +626,34 @@ export class CodexProvider {
         message.time = Date.now();
     }
     async fetchServerThreads() {
+        return this.fetchServerThreadsByArchiveState(false);
+    }
+    async refreshSessionMetadata(sessionId) {
+        const session = this.sessions.get(sessionId);
+        const result = await this.call("thread/read", {
+            threadId: sessionId,
+            includeTurns: false,
+        });
+        const threadObject = this.extractThreadObject(result);
+        if (!threadObject || Object.keys(threadObject).length === 0) {
+            return;
+        }
+        this.upsertSession({
+            id: sessionId,
+            title: this.extractThreadTitle(threadObject),
+            createdAt: this.extractCreatedAt(threadObject) ?? session?.createdAt ?? Date.now(),
+            updatedAt: this.extractUpdatedAt(threadObject) ?? session?.updatedAt ?? Date.now(),
+            archived: false,
+        }, true);
+    }
+    async fetchServerThreadsByArchiveState(archived) {
         const threads = [];
         let nextCursor = null;
         let hasRequestedFirstPage = false;
         do {
             const result = await this.call("thread/list", {
                 sourceKinds: THREAD_LIST_SOURCE_KINDS,
+                archived,
                 cursor: nextCursor,
             });
             const payload = this.asRecord(result);
@@ -622,7 +665,7 @@ export class CodexProvider {
                         ? payload.threads
                         : [];
             for (const entry of page) {
-                const parsed = this.parseThreadListEntry(entry);
+                const parsed = this.parseThreadListEntry(entry, archived);
                 if (parsed)
                     threads.push(parsed);
             }
@@ -664,7 +707,7 @@ export class CodexProvider {
         })
             .filter((value) => Boolean(value));
     }
-    parseThreadListEntry(value) {
+    parseThreadListEntry(value, archived = false) {
         const obj = this.asRecord(value);
         const id = this.extractThreadId(obj);
         if (!id)
@@ -674,6 +717,7 @@ export class CodexProvider {
             title: this.extractThreadTitle(obj),
             createdAt: this.extractCreatedAt(obj),
             updatedAt: this.extractUpdatedAt(obj),
+            archived,
         };
     }
     hasNextCursor(value) {
@@ -687,7 +731,7 @@ export class CodexProvider {
         const threadId = this.extractThreadId(payload);
         if (!threadId)
             return;
-        const title = this.extractThreadTitleFromUnknown(payload) ?? "Conversation";
+        const title = this.extractThreadTitleFromUnknown(payload);
         this.upsertSession({
             id: threadId,
             title,
@@ -695,22 +739,65 @@ export class CodexProvider {
             updatedAt: this.extractUpdatedAt(payload) ?? Date.now(),
         });
     }
-    upsertSession(input) {
-        const existing = this.sessions.get(input.id);
-        if (existing) {
-            existing.title = input.title ?? existing.title;
-            existing.createdAt = input.createdAt ?? existing.createdAt;
-            existing.updatedAt = input.updatedAt ?? existing.updatedAt;
-            return existing;
+    reconcileSessionsWithServer(activeThreads, archivedThreads = []) {
+        const localSessions = this.sessions;
+        const merged = new Map();
+        for (const thread of activeThreads) {
+            const session = this.mergeSession(localSessions.get(thread.id), { ...thread, archived: false });
+            merged.set(thread.id, session);
         }
-        const session = {
-            id: input.id,
-            title: input.title ?? "Conversation",
-            createdAt: input.createdAt ?? Date.now(),
-            updatedAt: input.updatedAt ?? Date.now(),
-            messages: [],
-        };
+        for (const thread of archivedThreads) {
+            if (merged.has(thread.id))
+                continue;
+            const session = this.mergeSession(localSessions.get(thread.id), { ...thread, archived: true });
+            merged.set(thread.id, session);
+        }
+        for (const [id, session] of localSessions.entries()) {
+            if (!merged.has(id)) {
+                merged.set(id, session);
+            }
+        }
+        this.sessions = merged;
+    }
+    mergeSession(existing, input) {
+        if (!existing) {
+            return {
+                id: input.id,
+                title: input.title ?? "Conversation",
+                createdAt: input.createdAt ?? Date.now(),
+                updatedAt: input.updatedAt ?? Date.now(),
+                archived: input.archived ?? false,
+                messages: [],
+            };
+        }
+        existing.title = input.title ?? existing.title;
+        existing.createdAt = input.createdAt ?? existing.createdAt;
+        existing.updatedAt = input.updatedAt != null
+            ? Math.max(existing.updatedAt, input.updatedAt)
+            : existing.updatedAt;
+        existing.archived = input.archived ?? existing.archived ?? false;
+        return existing;
+    }
+    upsertSession(input, emitUpdated = false) {
+        const existing = this.sessions.get(input.id);
+        const before = existing
+            ? {
+                title: existing.title,
+                createdAt: existing.createdAt,
+                updatedAt: existing.updatedAt,
+                archived: existing.archived ?? false,
+            }
+            : null;
+        const session = this.mergeSession(existing, input);
         this.sessions.set(input.id, session);
+        const changed = !before
+            || before.title !== session.title
+            || before.createdAt !== session.createdAt
+            || before.updatedAt !== session.updatedAt
+            || before.archived !== (session.archived ?? false);
+        if (emitUpdated && changed) {
+            this.emitter?.({ type: "session.updated", properties: { info: this.toSessionInfo(session) } });
+        }
         return session;
     }
     ensureLocalSession(sessionId) {
@@ -802,6 +889,7 @@ export class CodexProvider {
                 }
                 if (type === "commandexecution" || type === "enteredreviewmode" || type === "contextcompaction") {
                     const output = this.decodeCommandExecutionItemText(itemObject, type);
+                    const input = this.extractCommandExecutionInput(itemObject);
                     messages.push({
                         id: itemId,
                         role: "assistant",
@@ -810,6 +898,7 @@ export class CodexProvider {
                                 type: "tool",
                                 name: type === "commandexecution" ? "command" : "system",
                                 toolName: type === "commandexecution" ? "command" : "system",
+                                ...(input ? { input } : {}),
                                 output,
                                 state: "completed",
                                 sessionID: threadId,
@@ -963,10 +1052,16 @@ export class CodexProvider {
     }
     extractThreadTitle(payload) {
         const thread = this.asRecord(payload.thread);
-        return this.readString(thread.title)
-            ?? this.readString(thread.name)
-            ?? this.readString(payload.title)
-            ?? this.readString(payload.name);
+        const explicitName = this.readString(thread.name) ?? this.readString(payload.name);
+        if (explicitName)
+            return explicitName;
+        const explicitTitle = this.readString(thread.title) ?? this.readString(payload.title);
+        if (explicitTitle)
+            return explicitTitle;
+        const preview = this.readString(thread.preview) ?? this.readString(payload.preview);
+        if (!preview)
+            return undefined;
+        return preview.charAt(0).toUpperCase() + preview.slice(1);
     }
     extractTurnId(payload) {
         return (this.readString(payload.turnId)
@@ -1054,6 +1149,14 @@ export class CodexProvider {
         }
         return undefined;
     }
+    firstStringFromSources(sources, keys) {
+        for (const source of sources) {
+            const value = this.firstString(source, keys);
+            if (value)
+                return value;
+        }
+        return undefined;
+    }
     readArray(value) {
         return Array.isArray(value) ? value : [];
     }
@@ -1190,12 +1293,13 @@ export class CodexProvider {
                 "old_path",
                 "oldPath",
                 "from",
-            ]) ?? "file";
+            ]);
+            const normalizedPath = this.normalizeDisplayPath(path) ?? "file";
             const kind = this.firstString(obj, ["kind", "type", "action", "status"]) ?? "change";
             const diff = this.firstString(obj, ["diff", "unified_diff", "unifiedDiff", "patch"]) ?? "";
             return diff
-                ? `Path: ${path}\nKind: ${kind}\n\n\`\`\`diff\n${diff}\n\`\`\``
-                : `Path: ${path}\nKind: ${kind}`;
+                ? `Path: ${normalizedPath}\nKind: ${kind}\n\n\`\`\`diff\n${diff}\n\`\`\``
+                : `Path: ${normalizedPath}\nKind: ${kind}`;
         })
             .filter(Boolean);
         return rendered.length > 0 ? rendered.join("\n\n---\n\n") : undefined;
@@ -1225,6 +1329,20 @@ export class CodexProvider {
             .join("\n");
         return patch.trim() || undefined;
     }
+    normalizeDisplayPath(rawPath) {
+        if (!rawPath)
+            return undefined;
+        const trimmed = rawPath.trim();
+        if (!trimmed)
+            return undefined;
+        if (!path.isAbsolute(trimmed))
+            return trimmed;
+        const relative = path.relative(process.cwd(), trimmed);
+        if (!relative || relative.startsWith("..")) {
+            return trimmed;
+        }
+        return relative;
+    }
     normalizedFileChangeStatus(itemObject, isCompleted) {
         const status = this.readString(itemObject.status)
             ?? this.readString(this.asRecord(itemObject.status).type)
@@ -1235,8 +1353,40 @@ export class CodexProvider {
         return isCompleted ? "completed" : "inProgress";
     }
     extractToolInput(item, params) {
+        const normalizedType = this.normalizeStructuredType(this.readString(item.type) ?? "");
+        if (normalizedType === "commandexecution") {
+            return this.extractCommandExecutionInput(item, params);
+        }
         return item.input ?? item.command ?? item.path ?? item.args ?? params.command ?? params.path ?? undefined;
     }
+    extractCommandExecutionInput(item, params) {
+        const event = this.asRecord(params?.event);
+        const nestedItem = this.asRecord(event.item);
+        const sources = [item, params ?? {}, event, nestedItem];
+        const command = this.firstStringFromSources(sources, [
+            "command",
+            "cmd",
+            "raw_command",
+            "rawCommand",
+            "invocation",
+            "input",
+            "fullCommand",
+            "full_command",
+        ]);
+        const cwd = this.firstStringFromSources(sources, [
+            "cwd",
+            "workdir",
+            "workingDirectory",
+            "working_directory",
+        ]);
+        if (command && cwd)
+            return { command, cwd };
+        if (command)
+            return { command };
+        if (cwd)
+            return { cwd };
+        return undefined;
+    }
     describeCompletedItemOutput(item, params, normalizedType) {
         if (normalizedType === "commandexecution") {
             return this.firstString(item, ["stdout", "stderr", "text", "message", "summary"]);

package/package.json

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