lunel-cli 0.1.64 → 0.1.66

package/dist/ai/codex.d.ts

@@ -6,6 +6,7 @@ export declare class CodexProvider implements AIProvider {
     private nextId;
     private pending;
     private sessions;
+    private resumedThreadIds;
     private pendingPermissionRequestIds;
     private assistantMessageIdByTurnId;
     private partTextById;
@@ -71,6 +72,13 @@ export declare class CodexProvider implements AIProvider {
     private mergeSession;
     private upsertSession;
     private ensureLocalSession;
+    private getTransportThreadId;
+    private findSessionByThreadId;
+    private ensureThreadResumed;
+    private shouldTreatAsThreadNotFound;
+    private ensurePromptSessionReady;
+    private createContinuationSession;
+    private handleMissingThread;
     private resolveSessionFromPayload;
     private resolveInFlightTurnId;
     private decodeMessagesFromThreadRead;
@@ -94,6 +102,7 @@ export declare class CodexProvider implements AIProvider {
     private extractItemId;
     private extractTextPayload;
     private extractThreadId;
+    private extractThreadCwd;
     private extractCreatedAt;
     private extractUpdatedAt;
     private readTimestamp;
@@ -115,6 +124,8 @@ export declare class CodexProvider implements AIProvider {
     private renderUnifiedDiffBody;
     private extractCanonicalPatch;
     private normalizeDisplayPath;
+    private normalizeDirectoryPath;
+    private belongsToCurrentRoot;
     private normalizedFileChangeStatus;
     private extractToolInput;
     private extractCommandExecutionInput;

package/dist/ai/codex.js

@@ -13,6 +13,7 @@ export class CodexProvider {
     nextId = 1;
     pending = new Map();
     sessions = new Map();
+    resumedThreadIds = new Set();
     pendingPermissionRequestIds = new Map();
     assistantMessageIdByTurnId = new Map();
     partTextById = new Map();
@@ -51,7 +52,7 @@ export class CodexProvider {
         };
     }
     async createSession(title) {
-        const result = await this.call("thread/start", {});
+        const result = await this.call("thread/start", { cwd: process.cwd() });
         const threadId = this.extractThreadId(result);
         if (!threadId) {
             throw new Error("thread/start response missing threadId");
@@ -63,6 +64,7 @@ export class CodexProvider {
             createdAt: this.extractCreatedAt(result) ?? Date.now(),
             updatedAt: this.extractUpdatedAt(result) ?? Date.now(),
             archived: false,
+            cwd: this.extractThreadCwd(result) ?? process.cwd(),
         });
         return { session: this.toSessionInfo(session) };
     }
@@ -77,6 +79,7 @@ export class CodexProvider {
         }
         this.reconcileSessionsWithServer(activeThreads, archivedThreads);
         const sessions = Array.from(this.sessions.values())
+            .filter((session) => this.belongsToCurrentRoot(session))
             .sort((a, b) => a.updatedAt - b.updatedAt)
             .map((session) => this.toSessionInfo(session));
         return { sessions };
@@ -99,8 +102,9 @@ export class CodexProvider {
     }
     async getMessages(sessionId) {
         const session = this.ensureLocalSession(sessionId);
+        const transportThreadId = this.getTransportThreadId(session);
         const result = await this.call("thread/read", {
-            threadId: sessionId,
+            threadId: transportThreadId,
             includeTurns: true,
         });
         const threadObject = this.extractThreadObject(result);
@@ -117,6 +121,8 @@ export class CodexProvider {
             createdAt: this.extractCreatedAt(threadObject) ?? session.createdAt,
             updatedAt: this.extractUpdatedAt(threadObject) ?? session.updatedAt,
             archived: false,
+            transportThreadId,
+            cwd: this.extractThreadCwd(threadObject) ?? session.cwd,
         });
         return { messages: session.messages };
     }
@@ -125,11 +131,12 @@ export class CodexProvider {
         session.updatedAt = Date.now();
         (async () => {
             try {
+                let targetSession = await this.ensurePromptSessionReady(session);
                 let imageUrlKey = "url";
                 while (true) {
                     try {
                         await this.call("turn/start", {
-                            threadId: session.id,
+                            threadId: this.getTransportThreadId(targetSession),
                             input: this.makeTurnInputPayload(text, files, imageUrlKey),
                             ...(model ? { model: model.providerID === "codex" ? model.modelID : `${model.providerID}/${model.modelID}` } : {}),
                             ...(agent ? { agent } : {}),
@@ -137,6 +144,11 @@ export class CodexProvider {
                         break;
                     }
                     catch (err) {
+                        if (this.shouldTreatAsThreadNotFound(err)) {
+                            targetSession = await this.createContinuationSession(targetSession);
+                            imageUrlKey = "url";
+                            continue;
+                        }
                         if (imageUrlKey === "url"
                             && files.length > 0
                             && this.shouldRetryTurnStartWithImageURLField(err)) {
@@ -157,12 +169,13 @@ export class CodexProvider {
     }
     async abort(sessionId) {
         const session = this.ensureLocalSession(sessionId);
-        const turnId = session.activeTurnId ?? await this.resolveInFlightTurnId(sessionId);
+        const transportThreadId = this.getTransportThreadId(session);
+        const turnId = session.activeTurnId ?? await this.resolveInFlightTurnId(transportThreadId);
         if (!turnId) {
             throw new Error(`Session ${sessionId} has no active interruptible Codex turn`);
         }
         session.activeTurnId = turnId;
-        await this.call("turn/interrupt", { threadId: sessionId, turnId });
+        await this.call("turn/interrupt", { threadId: transportThreadId, turnId });
         return {};
     }
     async agents() {
@@ -660,8 +673,9 @@ export class CodexProvider {
     }
     async refreshSessionMetadata(sessionId) {
         const session = this.sessions.get(sessionId);
+        const transportThreadId = session ? this.getTransportThreadId(session) : sessionId;
         const result = await this.call("thread/read", {
-            threadId: sessionId,
+            threadId: transportThreadId,
             includeTurns: false,
         });
         const threadObject = this.extractThreadObject(result);
@@ -674,6 +688,8 @@ export class CodexProvider {
             createdAt: this.extractCreatedAt(threadObject) ?? session?.createdAt ?? Date.now(),
             updatedAt: this.extractUpdatedAt(threadObject) ?? session?.updatedAt ?? Date.now(),
             archived: false,
+            transportThreadId,
+            cwd: this.extractThreadCwd(threadObject) ?? session?.cwd,
         }, true);
     }
     async fetchServerThreadsByArchiveState(archived) {
@@ -748,6 +764,7 @@ export class CodexProvider {
             createdAt: this.extractCreatedAt(obj),
             updatedAt: this.extractUpdatedAt(obj),
             archived,
+            cwd: this.extractThreadCwd(obj),
         };
     }
     hasNextCursor(value) {
@@ -767,6 +784,7 @@ export class CodexProvider {
             title,
             createdAt: this.extractCreatedAt(payload) ?? Date.now(),
             updatedAt: this.extractUpdatedAt(payload) ?? Date.now(),
+            cwd: this.extractThreadCwd(payload),
         });
     }
     reconcileSessionsWithServer(activeThreads, archivedThreads = []) {
@@ -797,6 +815,8 @@ export class CodexProvider {
                 createdAt: input.createdAt ?? Date.now(),
                 updatedAt: input.updatedAt ?? Date.now(),
                 archived: input.archived ?? false,
+                transportThreadId: input.transportThreadId ?? input.id,
+                cwd: input.cwd,
                 messages: [],
             };
         }
@@ -806,25 +826,31 @@ export class CodexProvider {
             ? Math.max(existing.updatedAt, input.updatedAt)
             : existing.updatedAt;
         existing.archived = input.archived ?? existing.archived ?? false;
+        existing.transportThreadId = input.transportThreadId ?? input.id ?? existing.transportThreadId ?? existing.id;
+        existing.cwd = input.cwd ?? existing.cwd;
         return existing;
     }
     upsertSession(input, emitUpdated = false) {
-        const existing = this.sessions.get(input.id);
+        const existing = this.findSessionByThreadId(input.id);
         const before = existing
             ? {
                 title: existing.title,
                 createdAt: existing.createdAt,
                 updatedAt: existing.updatedAt,
                 archived: existing.archived ?? false,
+                transportThreadId: existing.transportThreadId ?? existing.id,
+                cwd: existing.cwd,
             }
             : null;
         const session = this.mergeSession(existing, input);
-        this.sessions.set(input.id, session);
+        this.sessions.set(session.id, session);
         const changed = !before
             || before.title !== session.title
             || before.createdAt !== session.createdAt
             || before.updatedAt !== session.updatedAt
-            || before.archived !== (session.archived ?? false);
+            || before.archived !== (session.archived ?? false)
+            || before.transportThreadId !== (session.transportThreadId ?? session.id)
+            || before.cwd !== session.cwd;
         if (emitUpdated && changed) {
             this.emitter?.({ type: "session.updated", properties: { info: this.toSessionInfo(session) } });
         }
@@ -836,9 +862,102 @@ export class CodexProvider {
             return existing;
         return this.upsertSession({ id: sessionId, title: "Conversation", createdAt: Date.now(), updatedAt: Date.now() });
     }
+    getTransportThreadId(session) {
+        return session.transportThreadId ?? session.id;
+    }
+    findSessionByThreadId(threadId) {
+        const direct = this.sessions.get(threadId);
+        if (direct)
+            return direct;
+        for (const session of this.sessions.values()) {
+            if ((session.transportThreadId ?? session.id) === threadId) {
+                return session;
+            }
+        }
+        return undefined;
+    }
+    async ensureThreadResumed(threadId) {
+        if (!threadId || this.resumedThreadIds.has(threadId)) {
+            return;
+        }
+        await this.call("thread/resume", { threadId });
+        this.resumedThreadIds.add(threadId);
+    }
+    shouldTreatAsThreadNotFound(error) {
+        const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+        if (message.includes("not materialized") || message.includes("not yet materialized")) {
+            return false;
+        }
+        return message.includes("thread not found") || message.includes("unknown thread");
+    }
+    async ensurePromptSessionReady(session) {
+        const threadId = this.getTransportThreadId(session);
+        try {
+            await this.ensureThreadResumed(threadId);
+            return session;
+        }
+        catch (error) {
+            if (!this.shouldTreatAsThreadNotFound(error)) {
+                throw error;
+            }
+            return this.createContinuationSession(session);
+        }
+    }
+    async createContinuationSession(session) {
+        const previousThreadId = this.getTransportThreadId(session);
+        this.handleMissingThread(session);
+        const result = await this.call("thread/start", {
+            ...(session.cwd ? { cwd: session.cwd } : { cwd: process.cwd() }),
+        });
+        const threadId = this.extractThreadId(result);
+        if (!threadId) {
+            throw new Error("thread/start response missing threadId");
+        }
+        session.transportThreadId = threadId;
+        session.updatedAt = Date.now();
+        session.archived = false;
+        this.upsertSession({
+            id: session.id,
+            title: this.extractThreadTitleFromUnknown(result) ?? session.title,
+            createdAt: session.createdAt,
+            updatedAt: this.extractUpdatedAt(result) ?? Date.now(),
+            archived: false,
+            transportThreadId: threadId,
+            cwd: this.extractThreadCwd(result) ?? session.cwd ?? process.cwd(),
+        }, true);
+        this.resumedThreadIds.add(threadId);
+        const systemMessageId = `system:${crypto.randomUUID()}`;
+        session.messages.push({
+            id: systemMessageId,
+            role: "assistant",
+            parts: [{
+                    id: `${systemMessageId}:text`,
+                    type: "text",
+                    text: `Continued from archived thread \`${previousThreadId}\``,
+                    sessionID: session.id,
+                    messageID: systemMessageId,
+                }],
+            time: Date.now(),
+        });
+        this.emitMessagePartEvent(session.id, systemMessageId, "assistant", {
+            id: `${systemMessageId}:text`,
+            type: "text",
+            text: `Continued from archived thread \`${previousThreadId}\``,
+            sessionID: session.id,
+            messageID: systemMessageId,
+        });
+        return session;
+    }
+    handleMissingThread(session) {
+        const threadId = this.getTransportThreadId(session);
+        this.resumedThreadIds.delete(threadId);
+        session.activeTurnId = undefined;
+    }
     resolveSessionFromPayload(payload) {
         const threadId = this.extractThreadId(payload);
-        return threadId ? this.ensureLocalSession(threadId) : undefined;
+        if (!threadId)
+            return undefined;
+        return this.findSessionByThreadId(threadId) ?? this.ensureLocalSession(threadId);
     }
     async resolveInFlightTurnId(threadId) {
         const result = await this.call("thread/read", { threadId, includeTurns: true });
@@ -1211,6 +1330,19 @@ export class CodexProvider {
         const thread = this.asRecord(obj.thread);
         return this.readString(thread.id) ?? this.readString(thread.threadId) ?? this.readString(thread.thread_id);
     }
+    extractThreadCwd(payload) {
+        const obj = this.extractThreadObject(payload);
+        const cwd = this.firstString(obj, [
+            "cwd",
+            "projectPath",
+            "project_path",
+            "gitWorkingDirectory",
+            "git_working_directory",
+            "workingDirectory",
+            "working_directory",
+        ]);
+        return cwd ? this.normalizeDirectoryPath(cwd) : undefined;
+    }
     extractCreatedAt(payload) {
         const obj = this.extractThreadObject(payload);
         return this.readTimestamp(obj.createdAt) ?? this.readTimestamp(obj.created_at);
@@ -1441,6 +1573,22 @@ export class CodexProvider {
         }
         return relative;
     }
+    normalizeDirectoryPath(rawPath) {
+        if (!rawPath)
+            return undefined;
+        const trimmed = rawPath.trim();
+        if (!trimmed)
+            return undefined;
+        return path.resolve(trimmed);
+    }
+    belongsToCurrentRoot(session) {
+        const sessionCwd = this.normalizeDirectoryPath(session.cwd);
+        const currentRoot = this.normalizeDirectoryPath(process.cwd());
+        if (!sessionCwd || !currentRoot) {
+            return false;
+        }
+        return sessionCwd === currentRoot;
+    }
     normalizedFileChangeStatus(itemObject, isCompleted) {
         const status = this.readString(itemObject.status)
             ?? this.readString(this.asRecord(itemObject.status).type)

package/dist/index.js

@@ -2494,11 +2494,56 @@ async function createSessionFromManager() {
     return (await response.json());
 }
 async function connectToCloudSession(sessionCode) {
-    const response = await fetch(`${MANAGER_URL}/v1/session/${sessionCode}`);
+    const response = await fetch(`${MANAGER_URL}/v1/session/resolve`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ code: sessionCode }),
+    });
     if (!response.ok) {
         throw new Error(`Failed to look up cloud session ${sessionCode}: ${response.status}`);
     }
-    return (await response.json());
+    const snapshot = await response.json();
+    if (!snapshot.exists || !snapshot.valid || !snapshot.primary || !snapshot.resumeToken || !snapshot.code) {
+        throw new Error(`Failed to look up cloud session ${sessionCode}: invalid or expired session`);
+    }
+    return {
+        sessionId: snapshot.sessionId || "",
+        code: snapshot.code,
+        password: snapshot.resumeToken,
+        primary: snapshot.primary,
+        backup: snapshot.backup ?? null,
+        state: snapshot.state,
+        expiresAt: snapshot.expiresAt,
+    };
+}
+async function resolveSessionByResumeToken(resumeToken) {
+    const response = await fetch(`${MANAGER_URL}/v1/session/resolve`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ resumeToken }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to resolve session from manager: ${response.status}`);
+    }
+    const snapshot = await response.json();
+    if (!snapshot.exists || !snapshot.valid || !snapshot.primary || !snapshot.resumeToken || !snapshot.code) {
+        if (snapshot.reason === "session_finalized" || snapshot.reason === "not_found") {
+            return null;
+        }
+        if (snapshot.state === "ended" || snapshot.state === "expired") {
+            return null;
+        }
+        throw new Error(`Session resolve returned invalid snapshot (${snapshot.reason || "unknown"})`);
+    }
+    return {
+        sessionId: snapshot.sessionId || "",
+        code: snapshot.code,
+        password: snapshot.resumeToken,
+        primary: snapshot.primary,
+        backup: snapshot.backup ?? null,
+        state: snapshot.state,
+        expiresAt: snapshot.expiresAt,
+    };
 }
 function displayQR(primaryGateway, backupGateway, code) {
     console.log("\n");
@@ -2776,13 +2821,30 @@ async function handleConnectionDrop(reason) {
         gracefulShutdown();
         return;
     }
-    try {
-        await connectWebSocket();
-        console.log(`[reconnect] connected via ${activeGatewayUrl}`);
-    }
-    catch (err) {
-        console.error(`[reconnect] failed on all gateways: ${err.message}`);
-        gracefulShutdown();
+    let attempt = 0;
+    while (!shuttingDown) {
+        attempt += 1;
+        const base = Math.min(250 * 2 ** (attempt - 1), 30_000);
+        const delayMs = Math.round(base * (0.8 + Math.random() * 0.4));
+        try {
+            const resolved = await resolveSessionByResumeToken(currentSessionPassword);
+            if (!resolved) {
+                console.error("[reconnect] session no longer exists or is finalized");
+                gracefulShutdown();
+                return;
+            }
+            currentSessionCode = resolved.code;
+            currentSessionPassword = resolved.password;
+            currentPrimaryGateway = normalizeGatewayUrl(resolved.primary);
+            currentBackupGateway = resolved.backup ? normalizeGatewayUrl(resolved.backup) : null;
+            await connectWebSocket();
+            console.log(`[reconnect] connected via ${activeGatewayUrl}`);
+            return;
+        }
+        catch (err) {
+            console.error(`[reconnect] attempt ${attempt} failed: ${err.message}`);
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
     }
 }
 async function main() {

package/package.json

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