lunel-cli 0.1.80 → 0.1.82

package/dist/ai/codex.d.ts

@@ -6,6 +6,7 @@ export declare class CodexProvider implements AIProvider {
     private nextId;
     private pending;
     private sessions;
+    private deletedThreadIds;
     private resumedThreadIds;
     private pendingPermissionRequestIds;
     private assistantMessageIdByTurnId;
@@ -22,7 +23,9 @@ export declare class CodexProvider implements AIProvider {
     getSession(id: string): Promise<{
         session: SessionInfo;
     }>;
-    deleteSession(id: string): Promise<Record<string, never>>;
+    deleteSession(id: string): Promise<{
+        deleted: boolean;
+    }>;
     getMessages(sessionId: string): Promise<{
         messages: MessageInfo[];
     }>;

package/dist/ai/codex.js

@@ -13,6 +13,7 @@ export class CodexProvider {
     nextId = 1;
     pending = new Map();
     sessions = new Map();
+    deletedThreadIds = new Set();
     resumedThreadIds = new Set();
     pendingPermissionRequestIds = new Map();
     assistantMessageIdByTurnId = new Map();
@@ -81,6 +82,8 @@ export class CodexProvider {
         }
         this.reconcileSessionsWithServer(activeThreads, archivedThreads);
         const sessions = Array.from(this.sessions.values())
+            .filter((session) => !session.archived)
+            .filter((session) => !this.deletedThreadIds.has(session.id))
             .filter((session) => this.belongsToCurrentRoot(session))
             .sort((a, b) => a.updatedAt - b.updatedAt)
             .map((session) => this.toSessionInfo(session));
@@ -99,8 +102,21 @@ export class CodexProvider {
         return { session: this.toSessionInfo(next) };
     }
     async deleteSession(id) {
+        const session = this.sessions.get(id);
+        this.deletedThreadIds.add(id);
         this.sessions.delete(id);
-        return {};
+        this.resumedThreadIds.delete(id);
+        try {
+            const params = { threadId: id };
+            if (session?.cwd) {
+                params.cwd = session.cwd;
+            }
+            await this.call("thread/archive", params);
+        }
+        catch {
+            // Match Remodex behavior: delete is optimistic locally, archive is best effort.
+        }
+        return { deleted: true };
     }
     async getMessages(sessionId) {
         const session = this.ensureLocalSession(sessionId);
@@ -783,10 +799,14 @@ export class CodexProvider {
         const localSessions = this.sessions;
         const merged = new Map();
         for (const thread of activeThreads) {
+            if (this.deletedThreadIds.has(thread.id))
+                continue;
             const session = this.mergeSession(localSessions.get(thread.id), { ...thread, archived: false });
             merged.set(thread.id, session);
         }
         for (const thread of archivedThreads) {
+            if (this.deletedThreadIds.has(thread.id))
+                continue;
             if (merged.has(thread.id))
                 continue;
             const session = this.mergeSession(localSessions.get(thread.id), { ...thread, archived: true });

package/dist/ai/index.d.ts

@@ -20,7 +20,9 @@ export declare class AiManager {
     getSession(backend: AiBackend, id: string): Promise<{
         session: import("./interface.js").SessionInfo;
     }>;
-    deleteSession(backend: AiBackend, id: string): Promise<Record<string, never>>;
+    deleteSession(backend: AiBackend, id: string): Promise<{
+        deleted: boolean;
+    }>;
     getMessages(backend: AiBackend, sessionId: string): Promise<{
         messages: import("./interface.js").MessageInfo[];
     }>;

package/dist/ai/interface.d.ts

@@ -53,7 +53,9 @@ export interface AIProvider {
     getSession(id: string): Promise<{
         session: SessionInfo;
     }>;
-    deleteSession(id: string): Promise<Record<string, never>>;
+    deleteSession(id: string): Promise<{
+        deleted: boolean;
+    }>;
     getMessages(sessionId: string): Promise<{
         messages: MessageInfo[];
     }>;

package/dist/ai/opencode.d.ts

@@ -21,7 +21,9 @@ export declare class OpenCodeProvider implements AIProvider {
     getSession(id: string): Promise<{
         session: SessionInfo;
     }>;
-    deleteSession(id: string): Promise<Record<string, never>>;
+    deleteSession(id: string): Promise<{
+        deleted: boolean;
+    }>;
     getMessages(sessionId: string): Promise<{
         messages: MessageInfo[];
     }>;

package/dist/ai/opencode.js

@@ -108,9 +108,7 @@ export class OpenCodeProvider {
     }
     async deleteSession(id) {
         const response = await this.client.session.delete({ path: { id } });
-        if (response.error)
-            throw new Error(JSON.stringify(response.error));
-        return {};
+        return { deleted: Boolean(requireData(response, "session.delete")) };
     }
     // -------------------------------------------------------------------------
     // Messages

package/dist/index.js

@@ -216,6 +216,7 @@ function hasFlag(args, flag) {
 }
 const EXTRA_PORTS = parseExtraPortsFromArgs(CLI_ARGS);
 const USE_APPLE_REVIEW_CODE = hasFlag(CLI_ARGS, "--abcd-code");
+const FORCE_NEW_CODE = hasFlag(CLI_ARGS, "--new-code");
 const SCAN_PORTS = Array.from(new Set([...DEV_PORTS, ...EXTRA_PORTS])).sort((a, b) => a - b);
 function samePortSet(a, b) {
     if (a.length !== b.length)
@@ -303,18 +304,31 @@ async function readCliConfig() {
         return {
             version: 1,
             deviceId: typeof parsed.deviceId === "string" && parsed.deviceId ? parsed.deviceId : generatePersistentSecret(32),
+            sessions: Array.isArray(parsed.sessions)
+                ? parsed.sessions.filter((entry) => (!!entry
+                    && typeof entry.rootDir === "string"
+                    && typeof entry.sessionPassword === "string"
+                    && typeof entry.savedAt === "number")).map((entry) => ({
+                    rootDir: entry.rootDir,
+                    sessionCode: typeof entry.sessionCode === "string" ? entry.sessionCode : null,
+                    sessionPassword: entry.sessionPassword,
+                    savedAt: entry.savedAt,
+                }))
+                : [],
         };
     }
     catch {
         return {
             version: 1,
             deviceId: generatePersistentSecret(32),
+            sessions: [],
         };
     }
 }
 async function writeCliConfig(config) {
     await fs.mkdir(path.dirname(CLI_CONFIG_PATH), { recursive: true });
     await fs.writeFile(CLI_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+    cliConfigPromise = Promise.resolve(config);
 }
 let cliConfigPromise = null;
 async function getCliConfig() {
@@ -323,6 +337,34 @@ async function getCliConfig() {
     }
     return await cliConfigPromise;
 }
+function getSavedSessionForRoot(config, rootDir) {
+    const sessions = Array.isArray(config.sessions) ? config.sessions : [];
+    return sessions.find((entry) => entry.rootDir === rootDir) || null;
+}
+async function saveSessionForRoot(sessionCode, sessionPassword) {
+    const config = await getCliConfig();
+    const sessions = Array.isArray(config.sessions) ? [...config.sessions] : [];
+    const nextEntry = {
+        rootDir: ROOT_DIR,
+        sessionCode,
+        sessionPassword,
+        savedAt: Date.now(),
+    };
+    const deduped = sessions.filter((entry) => entry.rootDir !== ROOT_DIR);
+    deduped.unshift(nextEntry);
+    await writeCliConfig({
+        ...config,
+        sessions: deduped.slice(0, 100),
+    });
+}
+async function clearSavedSessionForRoot() {
+    const config = await getCliConfig();
+    const sessions = Array.isArray(config.sessions) ? config.sessions : [];
+    await writeCliConfig({
+        ...config,
+        sessions: sessions.filter((entry) => entry.rootDir !== ROOT_DIR),
+    });
+}
 // ============================================================================
 // File System Handlers
 // ============================================================================
@@ -2596,7 +2638,20 @@ async function getAssignedProxyUrl(password) {
     url.searchParams.set("password", password);
     const response = await fetch(url);
     if (!response.ok) {
-        throw new Error(`Failed to get proxy from manager: ${response.status}`);
+        let message = `Failed to get proxy from manager: ${response.status}`;
+        try {
+            const payload = await response.json();
+            if (payload.error) {
+                message = payload.error;
+            }
+            else if (payload.reason) {
+                message = payload.reason;
+            }
+        }
+        catch {
+            // ignore parse failures and use the fallback message
+        }
+        throw new Error(message);
     }
     const payload = await response.json();
     if (typeof payload.proxyUrl !== "string" || !payload.proxyUrl) {
@@ -2604,6 +2659,30 @@ async function getAssignedProxyUrl(password) {
     }
     return normalizeGatewayUrl(payload.proxyUrl);
 }
+async function revokePassword(password, reason = "revoked by cli --new-code") {
+    const response = await fetch(new URL("/v2/revoke", MANAGER_URL), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ password, reason }),
+    });
+    if (response.ok || response.status === 404) {
+        return;
+    }
+    let message = `Failed to revoke previous session: ${response.status}`;
+    try {
+        const payload = await response.json();
+        if (payload.error) {
+            message = payload.error;
+        }
+        else if (payload.reason) {
+            message = payload.reason;
+        }
+    }
+    catch {
+        // ignore parse failures and use the fallback message
+    }
+    throw new Error(message);
+}
 function displayQR(code) {
     console.log("\n");
     qrcode.generate(code, { small: true }, (qr) => {
@@ -2875,8 +2954,10 @@ async function main() {
     if (EXTRA_PORTS.length > 0) {
         console.log(`Extra ports enabled: ${EXTRA_PORTS.join(", ")}`);
     }
+    let usedSavedSession = false;
     try {
-        await getCliConfig();
+        const cliConfig = await getCliConfig();
+        const savedSession = getSavedSessionForRoot(cliConfig, ROOT_DIR);
         console.log("Checking PTY runtime...");
         await ensurePtyBinaryReady();
         console.log("PTY runtime ready.\n");
@@ -2895,27 +2976,48 @@ async function main() {
                 checkDataChannelBackpressure();
             }
         });
-        let codeToAssemble;
+        let sessionCodeToUse = null;
+        let sessionPasswordToUse;
         if (USE_APPLE_REVIEW_CODE) {
-            codeToAssemble = APPLE_REVIEW_CODE;
-            currentSessionCode = codeToAssemble;
             console.log(`Using fixed review code: ${APPLE_REVIEW_CODE}`);
+            const assembled = await assembleWithCode(APPLE_REVIEW_CODE);
+            sessionCodeToUse = assembled.code;
+            sessionPasswordToUse = assembled.password;
+            await saveSessionForRoot(sessionCodeToUse, sessionPasswordToUse);
+        }
+        else if (!FORCE_NEW_CODE && savedSession) {
+            console.log(`Using saved session for ${ROOT_DIR}`);
+            sessionCodeToUse = savedSession.sessionCode;
+            sessionPasswordToUse = savedSession.sessionPassword;
+            usedSavedSession = true;
         }
         else {
+            if (FORCE_NEW_CODE && savedSession?.sessionPassword) {
+                await revokePassword(savedSession.sessionPassword);
+                await clearSavedSessionForRoot();
+            }
             const qr = await createQrCode();
-            codeToAssemble = qr.code;
             currentSessionCode = qr.code;
             displayQR(qr.code);
+            const assembled = await assembleWithCode(qr.code);
+            sessionCodeToUse = assembled.code;
+            sessionPasswordToUse = assembled.password;
+            await saveSessionForRoot(sessionCodeToUse, sessionPasswordToUse);
         }
-        const assembled = await assembleWithCode(codeToAssemble);
         resetReplayBuffer();
-        currentSessionCode = assembled.code;
-        currentSessionPassword = assembled.password;
-        currentPrimaryGateway = await getAssignedProxyUrl(assembled.password);
+        currentSessionCode = sessionCodeToUse;
+        currentSessionPassword = sessionPasswordToUse;
+        currentPrimaryGateway = await getAssignedProxyUrl(sessionPasswordToUse);
         activeGatewayUrl = currentPrimaryGateway;
         await connectWebSocket();
     }
     catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!USE_APPLE_REVIEW_CODE &&
+            usedSavedSession &&
+            /invalid|revoked|not found|expired|password invalid|password revoked/i.test(message)) {
+            await clearSavedSessionForRoot().catch(() => { });
+        }
         if (error instanceof Error) {
             console.error(`Error: ${error.message}`);
             if (error.stack)

package/package.json

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