lunel-cli 0.1.119 → 0.1.121

package/dist/ai/codex.d.ts

@@ -1,4 +1,4 @@
-import type { AIProvider, AiEventEmitter, CodexPromptOptions, AiSyncState, 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 CodexProvider implements AIProvider {
     private proc;
     private shuttingDown;
@@ -36,7 +36,6 @@ export declare class CodexProvider implements AIProvider {
     getMessages(sessionId: string): Promise<{
         messages: MessageInfo[];
     }>;
-    syncState(sessionIds?: string[]): Promise<AiSyncState>;
     prompt(sessionId: string, text: string, model?: ModelSelector, agent?: string, files?: FileAttachment[], codexOptions?: CodexPromptOptions): Promise<{
         ack: true;
     }>;
@@ -77,6 +76,7 @@ export declare class CodexProvider implements AIProvider {
     private refreshSessionMetadata;
     private fetchServerThreadsByArchiveState;
     private fetchModels;
+    private fetchModelById;
     private resolveModelId;
     private buildCollaborationMode;
     private parseThreadListEntry;

package/dist/ai/codex.js

@@ -268,80 +268,25 @@ export class CodexProvider {
         }
         return { messages: session.messages };
     }
-    async syncState(sessionIds = []) {
-        await this.listSessions().catch(() => ({ sessions: [] }));
-        const messageSessionIds = new Set(sessionIds);
-        for (const session of this.sessions.values()) {
-            if (session.activeTurnId)
-                messageSessionIds.add(session.id);
-        }
-        for (const pending of this.pendingPermissionRequestIds.values()) {
-            if (pending.sessionId)
-                messageSessionIds.add(pending.sessionId);
-        }
-        for (const pending of this.pendingQuestionRequestIds.values()) {
-            if (pending.sessionId)
-                messageSessionIds.add(pending.sessionId);
-        }
-        const messages = {};
-        const statuses = [];
-        await Promise.allSettled(Array.from(messageSessionIds).map(async (sessionId) => {
-            const response = await this.getMessages(sessionId);
-            messages[sessionId] = response.messages;
-            const session = this.sessions.get(sessionId);
-            if (!session)
-                return;
-            const activeTurnId = await this.resolveInFlightTurnId(sessionId).catch(() => undefined);
-            session.activeTurnId = activeTurnId;
-            if (activeTurnId) {
-                statuses.push({
-                    sessionID: sessionId,
-                    status: { type: "running", activeTurnId },
-                });
-            }
-        }));
-        return {
-            sessions: Array.from(this.sessions.values()).map((session) => this.toSessionInfo(session)),
-            statuses,
-            messages,
-            pendingPermissions: Array.from(this.pendingPermissionRequestIds.entries()).map(([id, pending]) => ({
-                id,
-                sessionID: pending.sessionId,
-                messageID: pending.messageId,
-                callID: pending.callId,
-                type: pending.method,
-                title: pending.method,
-                metadata: { method: pending.method },
-            })),
-            pendingQuestions: Array.from(this.pendingQuestionRequestIds.entries()).map(([id, pending]) => ({
-                id,
-                sessionID: pending.sessionId,
-                questions: [],
-                tool: {
-                    ...(pending.messageId ? { messageID: pending.messageId } : {}),
-                    ...(pending.callId ? { callID: pending.callId } : {}),
-                },
-            })),
-            statusAuthoritative: true,
-            generatedAt: Date.now(),
-        };
-    }
     async prompt(sessionId, text, model, agent, files = [], codexOptions) {
         const session = this.ensureLocalSession(sessionId);
         session.updatedAt = Date.now();
         (async () => {
             try {
-                const effortLevels = ["low", "medium", "high"];
-                const speedDelta = {
-                    fast: -1,
-                    balanced: 0,
-                    quality: 1,
-                };
-                const baseEffort = codexOptions?.reasoningEffort ?? "medium";
-                const baseIndex = effortLevels.indexOf(baseEffort);
-                const adjustedIndex = Math.max(0, Math.min(effortLevels.length - 1, baseIndex + (codexOptions?.speed ? speedDelta[codexOptions.speed] : 0)));
-                const reasoningEffort = effortLevels[adjustedIndex];
                 const modelId = await this.resolveModelId(model);
+                const modelInfo = await this.fetchModelById(modelId);
+                const effortLevels = modelInfo?.supportedReasoningEfforts.map((effort) => effort.reasoningEffort) ?? [];
+                const defaultEffort = modelInfo?.defaultReasoningEffort ?? effortLevels[0] ?? "medium";
+                const requestedEffort = codexOptions?.reasoningEffort;
+                const reasoningEffort = requestedEffort && effortLevels.includes(requestedEffort)
+                    ? requestedEffort
+                    : defaultEffort;
+                const requestedSpeedTier = codexOptions?.speed && codexOptions.speed !== "default"
+                    ? codexOptions.speed
+                    : undefined;
+                const serviceTier = requestedSpeedTier && modelInfo?.additionalSpeedTiers.includes(requestedSpeedTier)
+                    ? requestedSpeedTier
+                    : undefined;
                 const collaborationMode = this.buildCollaborationMode(agent, modelId, reasoningEffort);
                 // Freshly created sessions already have a live backend thread from
                 // thread/start. Forcing thread/resume here can attach stale state to a
@@ -354,7 +299,8 @@ export class CodexProvider {
                             threadId: session.id,
                             input: this.makeTurnInputPayload(text, files, imageUrlKey),
                             ...(modelId ? { model: modelId } : {}),
-                            ...(reasoningEffort ? { reasoningEffort } : {}),
+                            ...(reasoningEffort ? { effort: reasoningEffort } : {}),
+                            ...(serviceTier ? { serviceTier } : {}),
                             ...(collaborationMode ? { collaborationMode } : {}),
                         });
                         break;
@@ -400,6 +346,9 @@ export class CodexProvider {
                 name: item.displayName || item.model,
                 provider: "codex",
                 description: item.description,
+                defaultReasoningEffort: item.defaultReasoningEffort,
+                supportedReasoningEfforts: item.supportedReasoningEfforts,
+                additionalSpeedTiers: item.additionalSpeedTiers,
             },
         ]));
         const defaultModel = items.find((item) => item.isDefault)?.model;
@@ -1044,16 +993,49 @@ export class CodexProvider {
             const displayName = this.readString(obj.displayName)
                 ?? this.readString(obj.display_name)
                 ?? model;
+            const supportedReasoningEfforts = Array.isArray(obj.supportedReasoningEfforts)
+                ? obj.supportedReasoningEfforts
+                    .map((effort) => {
+                    const effortObj = this.asRecord(effort);
+                    const reasoningEffort = this.readString(effortObj.reasoningEffort)
+                        ?? this.readString(effortObj.reasoning_effort);
+                    if (!reasoningEffort)
+                        return undefined;
+                    const description = this.readString(effortObj.description);
+                    return {
+                        reasoningEffort,
+                        ...(description ? { description } : {}),
+                    };
+                })
+                    .filter((effort) => Boolean(effort))
+                : [];
+            const defaultReasoningEffort = this.readString(obj.defaultReasoningEffort)
+                ?? this.readString(obj.default_reasoning_effort);
+            const additionalSpeedTiers = Array.isArray(obj.additionalSpeedTiers)
+                ? obj.additionalSpeedTiers.filter((tier) => typeof tier === "string" && tier.length > 0)
+                : [];
             return {
                 id: this.readString(obj.id) ?? model,
                 model,
                 displayName,
                 description: this.readString(obj.description) ?? "",
                 isDefault: Boolean(obj.isDefault ?? obj.is_default),
+                ...(defaultReasoningEffort ? { defaultReasoningEffort } : {}),
+                supportedReasoningEfforts,
+                additionalSpeedTiers,
             };
         })
             .filter((value) => Boolean(value));
     }
+    async fetchModelById(modelId) {
+        const items = await this.fetchModels();
+        if (!modelId) {
+            return items.find((item) => item.isDefault) ?? items[0];
+        }
+        return items.find((item) => item.model === modelId || item.id === modelId)
+            ?? items.find((item) => item.isDefault)
+            ?? items[0];
+    }
     async resolveModelId(model) {
         if (model) {
             return model.providerID === "codex" ? model.modelID : `${model.providerID}/${model.modelID}`;

package/dist/ai/index.d.ts

@@ -14,24 +14,6 @@ export declare class AiManager {
             backend: AiBackend;
         }>;
     }>;
-    syncState(sessionIds?: Partial<Record<AiBackend, string[]>>): Promise<{
-        sessions: Array<Record<string, unknown> & {
-            backend: AiBackend;
-        }>;
-        statuses: Array<Record<string, unknown> & {
-            backend: AiBackend;
-        }>;
-        messages: Record<string, unknown>;
-        pendingPermissions: Array<Record<string, unknown> & {
-            backend: AiBackend;
-        }>;
-        pendingQuestions: Array<Record<string, unknown> & {
-            backend: AiBackend;
-        }>;
-        statusAuthoritativeByBackend: Partial<Record<AiBackend, boolean>>;
-        syncedBackends: AiBackend[];
-        generatedAt: number;
-    }>;
     createSession(backend: AiBackend, title?: string): Promise<{
         session: import("./interface.js").SessionInfo;
     }>;

package/dist/ai/index.js

@@ -68,51 +68,6 @@ export class AiManager {
         const sessions = results.flatMap((r) => (r.status === "fulfilled" ? r.value : []));
         return { sessions };
     }
-    async syncState(sessionIds = {}) {
-        const results = await Promise.allSettled(this._available.map(async (backend) => {
-            const provider = this._providers[backend];
-            const state = provider.syncState
-                ? await provider.syncState(sessionIds[backend])
-                : {
-                    sessions: (await provider.listSessions()).sessions,
-                    statuses: [],
-                    messages: {},
-                    generatedAt: Date.now(),
-                };
-            return { backend, state };
-        }));
-        const sessions = [];
-        const statuses = [];
-        const messages = {};
-        const pendingPermissions = [];
-        const pendingQuestions = [];
-        const statusAuthoritativeByBackend = {};
-        const syncedBackends = [];
-        for (const result of results) {
-            if (result.status !== "fulfilled")
-                continue;
-            const { backend, state } = result.value;
-            syncedBackends.push(backend);
-            statusAuthoritativeByBackend[backend] = state.statusAuthoritative !== false;
-            sessions.push(...(state.sessions ?? []).map((session) => ({ ...session, backend })));
-            statuses.push(...(state.statuses ?? []).map((status) => ({ ...status, backend })));
-            for (const [sessionId, value] of Object.entries(state.messages ?? {})) {
-                messages[`${backend}:${sessionId}`] = value;
-            }
-            pendingPermissions.push(...(state.pendingPermissions ?? []).map((permission) => ({ ...permission, backend })));
-            pendingQuestions.push(...(state.pendingQuestions ?? []).map((question) => ({ ...question, backend })));
-        }
-        return {
-            sessions,
-            statuses,
-            messages,
-            pendingPermissions,
-            pendingQuestions,
-            statusAuthoritativeByBackend,
-            syncedBackends,
-            generatedAt: Date.now(),
-        };
-    }
     // Session management — all require explicit backend
     createSession(backend, title) { return this.get(backend).createSession(title); }
     getSession(backend, id) { return this.get(backend).getSession(id); }

package/dist/ai/interface.d.ts

@@ -8,8 +8,8 @@ export interface ModelSelector {
     modelID: string;
 }
 export interface CodexPromptOptions {
-    reasoningEffort?: "low" | "medium" | "high";
-    speed?: "fast" | "balanced" | "quality";
+    reasoningEffort?: string;
+    speed?: string;
     permissionMode?: "default" | "full-access";
 }
 export interface FileAttachment {
@@ -35,19 +35,6 @@ export interface ProviderInfo {
     default: Record<string, string>;
     [key: string]: unknown;
 }
-export interface AiSessionStatus {
-    sessionID: string;
-    status: Record<string, unknown> | string;
-}
-export interface AiSyncState {
-    sessions: unknown[];
-    statuses: AiSessionStatus[];
-    messages: Record<string, MessageInfo[]>;
-    pendingPermissions?: Record<string, unknown>[];
-    pendingQuestions?: Record<string, unknown>[];
-    statusAuthoritative?: boolean;
-    generatedAt: number;
-}
 /**
  * Every AI backend (OpenCode, Codex, …) implements this interface.
  * Method names map 1-to-1 with the "ai" namespace actions in index.ts.
@@ -80,7 +67,6 @@ export interface AIProvider {
     getMessages(sessionId: string): Promise<{
         messages: MessageInfo[];
     }>;
-    syncState?(sessionIds?: string[]): Promise<AiSyncState>;
     prompt(sessionId: string, text: string, model?: ModelSelector, agent?: string, files?: FileAttachment[], codexOptions?: CodexPromptOptions): Promise<{
         ack: true;
     }>;

package/dist/ai/opencode.d.ts

@@ -1,4 +1,4 @@
-import type { AIProvider, AiEventEmitter, CodexPromptOptions, AiSyncState, 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;
@@ -33,7 +33,6 @@ export declare class OpenCodeProvider implements AIProvider {
     getMessages(sessionId: string): Promise<{
         messages: MessageInfo[];
     }>;
-    syncState(sessionIds?: string[]): Promise<AiSyncState>;
     prompt(sessionId: string, text: string, model?: ModelSelector, agent?: string, files?: FileAttachment[], codexOptions?: CodexPromptOptions): Promise<{
         ack: true;
     }>;
@@ -58,9 +57,6 @@ export declare class OpenCodeProvider implements AIProvider {
     private sendPromptAsync;
     private reconcileOpenCodeState;
     private refreshBusySessionMessages;
-    private fetchSessionStatuses;
-    private listPendingPermissions;
-    private listPendingQuestions;
     private refreshSessionsMetadata;
     private refreshPendingPermissions;
     private refreshPendingQuestions;

package/dist/ai/opencode.js

@@ -102,10 +102,19 @@ function normalizeOpenCodePart(part) {
             });
         }
         else if (status === "error") {
-            normalized.error = readString(state.error) ?? "Tool failed";
-            const errorMessage = readString(state.error);
-            if (errorMessage)
-                normalized.output = errorMessage;
+            if (metadata.interrupted === true) {
+                normalized.state = "completed";
+                normalized.interrupted = true;
+                const interruptedOutput = readString(metadata.output);
+                if (interruptedOutput)
+                    normalized.output = interruptedOutput;
+            }
+            else {
+                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) {
@@ -393,57 +402,10 @@ export class OpenCodeProvider {
             throw err;
         }
     }
-    async syncState(sessionIds = []) {
-        const [sessionsResult, statusesResult, permissionsResult, questionsResult] = await Promise.allSettled([
-            this.listSessions(),
-            this.fetchSessionStatuses(),
-            this.listPendingPermissions(),
-            this.listPendingQuestions(),
-        ]);
-        const sessions = sessionsResult.status === "fulfilled"
-            ? (sessionsResult.value.sessions ?? [])
-            : [];
-        const statuses = statusesResult.status === "fulfilled" ? statusesResult.value : [];
-        const pendingPermissions = permissionsResult.status === "fulfilled" ? permissionsResult.value : [];
-        const pendingQuestions = questionsResult.status === "fulfilled" ? questionsResult.value : [];
-        const messageSessionIds = new Set(sessionIds);
-        for (const entry of statuses) {
-            const statusObj = typeof entry.status === "object" && entry.status !== null ? entry.status : {};
-            const statusType = typeof statusObj.type === "string" ? statusObj.type.toLowerCase() : String(entry.status ?? "").toLowerCase();
-            if (statusType === "busy" || statusType === "running" || statusType === "working" || statusType === "retry") {
-                messageSessionIds.add(entry.sessionID);
-            }
-        }
-        for (const permission of pendingPermissions) {
-            const sessionID = this.readString(permission.sessionID) ?? this.readString(permission.sessionId);
-            if (sessionID)
-                messageSessionIds.add(sessionID);
-        }
-        for (const question of pendingQuestions) {
-            const sessionID = this.readString(question.sessionID) ?? this.readString(question.sessionId);
-            if (sessionID)
-                messageSessionIds.add(sessionID);
-        }
-        const messages = {};
-        await Promise.allSettled(Array.from(messageSessionIds).map(async (sessionId) => {
-            const response = await this.getMessages(sessionId);
-            messages[sessionId] = response.messages;
-        }));
-        return {
-            sessions,
-            statuses,
-            messages,
-            pendingPermissions,
-            pendingQuestions,
-            statusAuthoritative: statusesResult.status === "fulfilled",
-            generatedAt: Date.now(),
-        };
-    }
     // -------------------------------------------------------------------------
     // Interaction
     // -------------------------------------------------------------------------
     async prompt(sessionId, text, model, agent, files = [], codexOptions) {
-        void codexOptions;
         if (sessionId)
             this.lastActiveSessionId = sessionId;
         if (VERBOSE_AI_LOGS) {
@@ -457,7 +419,7 @@ export class OpenCodeProvider {
         // Fire-and-forget — results come back through the SSE event stream.
         // Prefer the async prompt endpoint so long-running turns do not get tied
         // to the request lifecycle the way the basic prompt route can be.
-        this.sendPromptAsync(sessionId, text, model, agent, files).catch((err) => {
+        this.sendPromptAsync(sessionId, text, model, agent, files, codexOptions).catch((err) => {
             console.error("[ai] prompt error:", err.message);
             this.emitter?.({
                 type: "prompt_error",
@@ -644,7 +606,7 @@ export class OpenCodeProvider {
             }
         }
     }
-    async sendPromptAsync(sessionId, text, model, agent, files = []) {
+    async sendPromptAsync(sessionId, text, model, agent, files = [], promptOptions) {
         const server = this.server;
         const authHeader = this.authHeader;
         if (!server || !authHeader) {
@@ -665,6 +627,7 @@ export class OpenCodeProvider {
                 ],
                 ...(model ? { model } : {}),
                 ...(agent ? { agent } : {}),
+                ...(promptOptions?.reasoningEffort ? { variant: promptOptions.reasoningEffort } : {}),
             }),
         });
         if (!response.ok) {
@@ -736,43 +699,6 @@ export class OpenCodeProvider {
             }
         }
     }
-    async fetchSessionStatuses() {
-        const payload = await this.fetchOpenCodeJson("/session/status", { method: "GET" });
-        if (!payload || typeof payload !== "object")
-            return [];
-        return Object.entries(payload).map(([sessionID, status]) => ({
-            sessionID,
-            status: status,
-        }));
-    }
-    async listPendingPermissions() {
-        const permissionApi = this.client?.permission;
-        if (!permissionApi?.list)
-            return [];
-        const response = await permissionApi.list();
-        const data = Array.isArray(response.data) ? response.data : [];
-        return data
-            .map((entry) => normalizePermissionProperties(this.asRecord(entry)))
-            .filter((entry) => !!this.readString(entry.id));
-    }
-    async listPendingQuestions() {
-        const data = await this.fetchOpenCodeJson("/question", { method: "GET" });
-        const questions = Array.isArray(data) ? data : [];
-        return questions
-            .flatMap((entry) => {
-            const question = this.asRecord(entry);
-            const id = this.readString(question.id);
-            const sessionID = this.readString(question.sessionID) ?? this.readString(question.sessionId);
-            if (!id || !sessionID)
-                return [];
-            return [{
-                    id,
-                    sessionID,
-                    questions: Array.isArray(question.questions) ? question.questions : [],
-                    tool: typeof question.tool === "object" && question.tool !== null ? question.tool : undefined,
-                }];
-        });
-    }
     async refreshSessionsMetadata() {
         const response = await this.client.session.list();
         const sessions = Array.isArray(response.data) ? response.data : [];

package/dist/index.js

@@ -90,13 +90,10 @@ let aiManagerInitPromise = null;
 // Proxy tunnel management
 let currentSessionCode = null;
 let currentSessionPassword = null;
-let currentManagerSessionId = null;
 let currentPrimaryGateway = DEFAULT_PROXY_URL;
 let activeGatewayUrl = DEFAULT_PROXY_URL;
-let appPeerConnected = false;
 let shuttingDown = false;
 let activeV2Transport = null;
-const runningAiSessions = new Set();
 const trackedEditorFiles = new Map();
 const trackedEditorDirectories = new Map();
 const pendingTrackedFileChecks = new Set();
@@ -305,21 +302,7 @@ async function readCliConfig() {
                     rootDir: entry.rootDir,
                     sessionCode: typeof entry.sessionCode === "string" ? entry.sessionCode : null,
                     sessionPassword: entry.sessionPassword,
-                    managerSessionId: typeof entry.managerSessionId === "string" ? entry.managerSessionId : null,
                     savedAt: entry.savedAt,
-                    pushDevices: Array.isArray(entry.pushDevices)
-                        ? entry.pushDevices.filter((device) => (!!device
-                            && typeof device.phoneId === "string"
-                            && typeof device.notificationsEnabled === "boolean"
-                            && typeof device.updatedAt === "number"
-                            && (typeof device.expoPushToken === "string" || device.expoPushToken === null))).map((device) => ({
-                            phoneId: device.phoneId,
-                            expoPushToken: device.expoPushToken,
-                            notificationsEnabled: device.notificationsEnabled,
-                            platform: typeof device.platform === "string" ? device.platform : null,
-                            updatedAt: device.updatedAt,
-                        }))
-                        : [],
                 }))
                 : [],
         };
@@ -334,9 +317,7 @@ async function readCliConfig() {
 }
 async function writeCliConfig(config) {
     await fs.mkdir(path.dirname(CLI_CONFIG_PATH), { recursive: true });
-    const tmpPath = `${CLI_CONFIG_PATH}.${process.pid}.${Date.now()}.tmp`;
-    await fs.writeFile(tmpPath, JSON.stringify(config, null, 2), "utf-8");
-    await fs.rename(tmpPath, CLI_CONFIG_PATH);
+    await fs.writeFile(CLI_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
     cliConfigPromise = Promise.resolve(config);
 }
 let cliConfigPromise = null;
@@ -350,17 +331,14 @@ 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, managerSessionId) {
+async function saveSessionForRoot(sessionCode, sessionPassword) {
     const config = await getCliConfig();
     const sessions = Array.isArray(config.sessions) ? [...config.sessions] : [];
-    const previous = sessions.find((entry) => entry.rootDir === ROOT_DIR);
     const nextEntry = {
         rootDir: ROOT_DIR,
         sessionCode,
         sessionPassword,
-        managerSessionId,
         savedAt: Date.now(),
-        pushDevices: previous?.pushDevices ?? [],
     };
     const deduped = sessions.filter((entry) => entry.rootDir !== ROOT_DIR);
     deduped.unshift(nextEntry);
@@ -369,192 +347,6 @@ async function saveSessionForRoot(sessionCode, sessionPassword, managerSessionId
         sessions: deduped.slice(0, 100),
     });
 }
-async function savePushDeviceForCurrentSession(payload) {
-    if (!currentSessionPassword) {
-        throw Object.assign(new Error("No active session"), { code: "EUNAVAILABLE" });
-    }
-    const phoneId = typeof payload.phoneId === "string" ? payload.phoneId.trim() : "";
-    if (!phoneId) {
-        throw Object.assign(new Error("phoneId is required"), { code: "EINVAL" });
-    }
-    const expoPushToken = typeof payload.expoPushToken === "string" && payload.expoPushToken.trim()
-        ? payload.expoPushToken.trim()
-        : null;
-    const notificationsEnabled = payload.notificationsEnabled === true && Boolean(expoPushToken);
-    const platform = typeof payload.platform === "string" && payload.platform.trim()
-        ? payload.platform.trim()
-        : null;
-    const config = await getCliConfig();
-    const sessions = Array.isArray(config.sessions) ? [...config.sessions] : [];
-    const now = Date.now();
-    const currentEntry = sessions.find((entry) => entry.rootDir === ROOT_DIR) ?? {
-        rootDir: ROOT_DIR,
-        sessionCode: currentSessionCode,
-        sessionPassword: currentSessionPassword,
-        managerSessionId: currentManagerSessionId,
-        savedAt: now,
-        pushDevices: [],
-    };
-    const nextDevices = (currentEntry.pushDevices ?? []).filter((device) => device.phoneId !== phoneId);
-    nextDevices.unshift({
-        phoneId,
-        expoPushToken,
-        notificationsEnabled,
-        platform,
-        updatedAt: now,
-    });
-    const nextEntry = {
-        ...currentEntry,
-        sessionCode: currentSessionCode,
-        sessionPassword: currentSessionPassword,
-        managerSessionId: currentManagerSessionId,
-        savedAt: now,
-        pushDevices: nextDevices.slice(0, 10),
-    };
-    const deduped = sessions.filter((entry) => entry.rootDir !== ROOT_DIR);
-    deduped.unshift(nextEntry);
-    await writeCliConfig({
-        ...config,
-        sessions: deduped.slice(0, 100),
-    });
-    return { ok: true, notificationsEnabled, tokenStored: Boolean(expoPushToken) };
-}
-function readAiEventSessionId(event) {
-    const properties = event.properties || {};
-    const info = properties.info && typeof properties.info === "object" ? properties.info : {};
-    return ((typeof properties.sessionID === "string" && properties.sessionID)
-        || (typeof properties.sessionId === "string" && properties.sessionId)
-        || (typeof info.sessionID === "string" && info.sessionID)
-        || (typeof info.sessionId === "string" && info.sessionId)
-        || (typeof info.id === "string" && info.id)
-        || null);
-}
-function readAiStatusType(status) {
-    if (typeof status === "string")
-        return status.toLowerCase();
-    if (status && typeof status === "object") {
-        const value = status.type;
-        if (typeof value === "string")
-            return value.toLowerCase();
-    }
-    return "";
-}
-function isRunningAiStatus(status) {
-    const value = readAiStatusType(status);
-    return value === "running" || value === "busy" || value === "working" || value === "processing" || value === "retry";
-}
-function isTerminalAiStatus(status) {
-    const value = readAiStatusType(status);
-    return (value === "idle"
-        || value === "complete"
-        || value === "completed"
-        || value === "done"
-        || value === "finished"
-        || value === "error"
-        || value === "failed"
-        || value === "cancelled"
-        || value === "canceled");
-}
-async function getCurrentNotificationDevices() {
-    const config = await getCliConfig();
-    const saved = getSavedSessionForRoot(config, ROOT_DIR);
-    if (!saved || saved.sessionPassword !== currentSessionPassword)
-        return [];
-    return (saved.pushDevices ?? []).filter((device) => (device.notificationsEnabled
-        && typeof device.expoPushToken === "string"
-        && device.expoPushToken.length > 0));
-}
-async function clearInvalidNotificationDevices(phoneIds) {
-    if (phoneIds.length === 0)
-        return;
-    const invalidPhoneIds = new Set(phoneIds);
-    const config = await getCliConfig();
-    const sessions = Array.isArray(config.sessions) ? [...config.sessions] : [];
-    const saved = getSavedSessionForRoot(config, ROOT_DIR);
-    if (!saved?.pushDevices?.length)
-        return;
-    const nextEntry = {
-        ...saved,
-        pushDevices: saved.pushDevices.map((device) => (invalidPhoneIds.has(device.phoneId)
-            ? { ...device, expoPushToken: null, notificationsEnabled: false, updatedAt: Date.now() }
-            : device)),
-    };
-    const deduped = sessions.filter((entry) => entry.rootDir !== ROOT_DIR);
-    deduped.unshift(nextEntry);
-    await writeCliConfig({
-        ...config,
-        sessions: deduped.slice(0, 100),
-    });
-}
-async function notifyManagerAiCompletion(backend, aiSessionId) {
-    if (appPeerConnected)
-        return;
-    if (!currentManagerSessionId || !currentSessionPassword)
-        return;
-    const devices = await getCurrentNotificationDevices();
-    if (devices.length === 0)
-        return;
-    const response = await fetch(new URL("/v1/notifications/ai-complete", MANAGER_URL), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        signal: AbortSignal.timeout(10_000),
-        body: JSON.stringify({
-            sessionId: currentManagerSessionId,
-            resumeToken: currentSessionPassword,
-            backend,
-            aiSessionId,
-            devices: devices.map((device) => ({
-                phoneId: device.phoneId,
-                expoPushToken: device.expoPushToken,
-                platform: device.platform,
-            })),
-        }),
-    });
-    if (!response.ok) {
-        if (DEBUG_MODE) {
-            console.warn(`[notifications] manager notify failed: ${response.status}`);
-        }
-        return;
-    }
-    const body = await response.json().catch(() => ({}));
-    const invalidPhoneIds = Array.isArray(body.invalidPhoneIds)
-        ? body.invalidPhoneIds.filter((value) => typeof value === "string")
-        : [];
-    if (invalidPhoneIds.length > 0) {
-        await clearInvalidNotificationDevices(invalidPhoneIds);
-    }
-}
-function handleAiNotificationEvent(backend, event) {
-    const sessionId = readAiEventSessionId(event);
-    if (!sessionId)
-        return;
-    const key = `${backend}:${sessionId}`;
-    if (event.type === "session.status") {
-        if (isRunningAiStatus(event.properties.status)) {
-            runningAiSessions.add(key);
-            return;
-        }
-        if (!isTerminalAiStatus(event.properties.status))
-            return;
-        if (!runningAiSessions.delete(key))
-            return;
-        void notifyManagerAiCompletion(backend, sessionId).catch((error) => {
-            if (DEBUG_MODE) {
-                console.warn("[notifications] failed to notify manager:", error instanceof Error ? error.message : String(error));
-            }
-        });
-        return;
-    }
-    if (event.type !== "session.idle")
-        return;
-    if (!runningAiSessions.delete(key))
-        return;
-    void notifyManagerAiCompletion(backend, sessionId).catch((error) => {
-        if (DEBUG_MODE) {
-            console.warn("[notifications] failed to notify manager:", error instanceof Error ? error.message : String(error));
-        }
-    });
-}
 async function clearSavedSessionForRoot() {
     const config = await getCliConfig();
     const sessions = Array.isArray(config.sessions) ? config.sessions : [];
@@ -1741,7 +1533,6 @@ function handleSystemCapabilities() {
         platform: os.platform(),
         rootDir: ROOT_DIR,
         hostname: os.hostname(),
-        managerSessionId: currentManagerSessionId,
     };
 }
 function handleSystemPing() {
@@ -2715,9 +2506,6 @@ async function processMessage(message) {
                     case "ping":
                         result = handleSystemPing();
                         break;
-                    case "setPushToken":
-                        result = await savePushDeviceForCurrentSession(payload);
-                        break;
                     case "pairDevice": {
                         throw Object.assign(new Error("pairDevice is no longer supported"), { code: "EINVAL" });
                     }
@@ -2928,14 +2716,6 @@ async function processMessage(message) {
                     case "listSessions":
                         result = await aiManager.listAllSessions();
                         break;
-                    case "syncState": {
-                        const rawSessionIds = payload.sessionIds;
-                        result = await aiManager.syncState({
-                            opencode: Array.isArray(rawSessionIds?.opencode) ? rawSessionIds.opencode.filter((id) => typeof id === "string") : undefined,
-                            codex: Array.isArray(rawSessionIds?.codex) ? rawSessionIds.codex.filter((id) => typeof id === "string") : undefined,
-                        });
-                        break;
-                    }
                     case "getSession":
                         result = await aiManager.getSession(backend, payload.id);
                         break;
@@ -3107,11 +2887,7 @@ async function assembleWithCode(code) {
                     return;
                 settled = true;
                 ws.send(JSON.stringify({ type: "ack" }));
-                resolve({
-                    code: parsed.code,
-                    password: parsed.password,
-                    sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : null,
-                });
+                resolve({ code: parsed.code, password: parsed.password });
             }
             catch (error) {
                 fail(error instanceof Error ? error : new Error(String(error)));
@@ -3373,7 +3149,6 @@ function startAiManagerInBackground() {
             }
             aiManager = manager;
             aiManager.subscribe((backend, event) => {
-                handleAiNotificationEvent(backend, event);
                 emitAppEvent({
                     v: 1,
                     id: `evt-${Date.now()}`,
@@ -3413,19 +3188,16 @@ async function connectWebSocketV2() {
                 if (message.type === "connected")
                     return;
                 if (message.type === "peer_connected") {
-                    appPeerConnected = true;
                     console.log("App connected!\n");
                     void publishDiscoveredPorts(true);
                     return;
                 }
                 if (message.type === "peer_disconnected") {
-                    appPeerConnected = false;
                     console.log("App disconnected. Waiting for reconnect window.\n");
                     stopPortSync();
                     return;
                 }
                 if (message.type === "app_disconnected") {
-                    appPeerConnected = false;
                     if (message.reconnectDeadline) {
                         console.log(`[session] app disconnected, waiting until ${new Date(message.reconnectDeadline).toISOString()}`);
                     }
@@ -3530,7 +3302,6 @@ async function main() {
             displaySavedSessionNotice();
             sessionCodeToUse = savedSession.sessionCode;
             sessionPasswordToUse = savedSession.sessionPassword;
-            currentManagerSessionId = savedSession.managerSessionId ?? null;
             usedSavedSession = true;
         }
         else {
@@ -3544,8 +3315,7 @@ async function main() {
             const assembled = await assembleWithCode(qr.code);
             sessionCodeToUse = assembled.code;
             sessionPasswordToUse = assembled.password;
-            currentManagerSessionId = assembled.sessionId;
-            await saveSessionForRoot(sessionCodeToUse, sessionPasswordToUse, currentManagerSessionId);
+            await saveSessionForRoot(sessionCodeToUse, sessionPasswordToUse);
         }
         currentSessionCode = sessionCodeToUse;
         currentSessionPassword = sessionPasswordToUse;

package/package.json

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