lunel-cli 0.1.117 → 0.1.119

package/dist/ai/codex.d.ts

@@ -1,4 +1,4 @@
-import type { AIProvider, AiEventEmitter, CodexPromptOptions, FileAttachment, ModelSelector, MessageInfo, ProviderInfo, SessionInfo, ShareInfo } from "./interface.js";
+import type { AIProvider, AiEventEmitter, CodexPromptOptions, AiSyncState, FileAttachment, ModelSelector, MessageInfo, ProviderInfo, SessionInfo, ShareInfo } from "./interface.js";
 export declare class CodexProvider implements AIProvider {
     private proc;
     private shuttingDown;
@@ -36,6 +36,7 @@ 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;
     }>;

package/dist/ai/codex.js

@@ -268,6 +268,64 @@ 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();

package/dist/ai/index.d.ts

@@ -14,6 +14,24 @@ 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,6 +68,51 @@ 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

@@ -35,6 +35,19 @@ 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.
@@ -67,6 +80,7 @@ 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, FileAttachment, ModelSelector, MessageInfo, ProviderInfo, SessionInfo, ShareInfo } from "./interface.js";
+import type { AIProvider, AiEventEmitter, CodexPromptOptions, AiSyncState, FileAttachment, ModelSelector, MessageInfo, ProviderInfo, SessionInfo, ShareInfo } from "./interface.js";
 export declare class OpenCodeProvider implements AIProvider {
     private client;
     private server;
@@ -33,6 +33,7 @@ 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;
     }>;
@@ -57,6 +58,9 @@ 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

@@ -393,6 +393,52 @@ 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
     // -------------------------------------------------------------------------
@@ -690,6 +736,43 @@ 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,10 +90,13 @@ 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();
@@ -302,7 +305,21 @@ 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,
+                        }))
+                        : [],
                 }))
                 : [],
         };
@@ -317,7 +334,9 @@ async function readCliConfig() {
 }
 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");
+    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);
     cliConfigPromise = Promise.resolve(config);
 }
 let cliConfigPromise = null;
@@ -331,14 +350,17 @@ 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) {
+async function saveSessionForRoot(sessionCode, sessionPassword, managerSessionId) {
     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);
@@ -347,6 +369,192 @@ async function saveSessionForRoot(sessionCode, sessionPassword) {
         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 : [];
@@ -398,6 +606,51 @@ async function handleFsLs(payload) {
     }
     return { path: reqPath, entries: result };
 }
+async function handleFsSearchFiles(payload) {
+    const reqPath = payload.path || ".";
+    const query = typeof payload.query === "string" ? payload.query.trim().toLowerCase() : "";
+    const maxResults = Math.max(1, Math.min(payload.maxResults || 10, 10));
+    const safePath = assertSafePath(reqPath);
+    const rootIgnore = await loadGitignore(ROOT_DIR);
+    const matches = [];
+    async function searchDir(dirPath, relativePath, ig) {
+        if (matches.length >= maxResults)
+            return;
+        const localIgnore = ignore().add(ig);
+        try {
+            const localGitignorePath = path.join(dirPath, ".gitignore");
+            const content = await fs.readFile(localGitignorePath, "utf-8");
+            localIgnore.add(content);
+        }
+        catch {
+            // No local .gitignore
+        }
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (matches.length >= maxResults)
+                break;
+            const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+            const checkPath = entry.isDirectory() ? `${relPath}/` : relPath;
+            if (localIgnore.ignores(checkPath))
+                continue;
+            const fullPath = path.join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                await searchDir(fullPath, relPath, localIgnore);
+            }
+            else if (entry.isFile() && relPath.toLowerCase().includes(query)) {
+                matches.push({ path: relPath });
+            }
+        }
+    }
+    const stat = await fs.stat(safePath);
+    if (stat.isDirectory()) {
+        await searchDir(safePath, reqPath === "." ? "" : reqPath, rootIgnore);
+    }
+    else if (stat.isFile() && reqPath.toLowerCase().includes(query)) {
+        matches.push({ path: reqPath });
+    }
+    return { path: reqPath, query, maxResults, files: matches };
+}
 async function handleFsStat(payload) {
     const reqPath = payload.path;
     if (!reqPath)
@@ -1488,6 +1741,7 @@ function handleSystemCapabilities() {
         platform: os.platform(),
         rootDir: ROOT_DIR,
         hostname: os.hostname(),
+        managerSessionId: currentManagerSessionId,
     };
 }
 function handleSystemPing() {
@@ -2461,6 +2715,9 @@ 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" });
                     }
@@ -2473,6 +2730,9 @@ async function processMessage(message) {
                     case "ls":
                         result = await handleFsLs(payload);
                         break;
+                    case "searchFiles":
+                        result = await handleFsSearchFiles(payload);
+                        break;
                     case "stat":
                         result = await handleFsStat(payload);
                         break;
@@ -2668,6 +2928,14 @@ 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;
@@ -2839,7 +3107,11 @@ async function assembleWithCode(code) {
                     return;
                 settled = true;
                 ws.send(JSON.stringify({ type: "ack" }));
-                resolve({ code: parsed.code, password: parsed.password });
+                resolve({
+                    code: parsed.code,
+                    password: parsed.password,
+                    sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : null,
+                });
             }
             catch (error) {
                 fail(error instanceof Error ? error : new Error(String(error)));
@@ -3101,6 +3373,7 @@ function startAiManagerInBackground() {
             }
             aiManager = manager;
             aiManager.subscribe((backend, event) => {
+                handleAiNotificationEvent(backend, event);
                 emitAppEvent({
                     v: 1,
                     id: `evt-${Date.now()}`,
@@ -3140,16 +3413,19 @@ 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()}`);
                     }
@@ -3254,6 +3530,7 @@ async function main() {
             displaySavedSessionNotice();
             sessionCodeToUse = savedSession.sessionCode;
             sessionPasswordToUse = savedSession.sessionPassword;
+            currentManagerSessionId = savedSession.managerSessionId ?? null;
             usedSavedSession = true;
         }
         else {
@@ -3267,7 +3544,8 @@ async function main() {
             const assembled = await assembleWithCode(qr.code);
             sessionCodeToUse = assembled.code;
             sessionPasswordToUse = assembled.password;
-            await saveSessionForRoot(sessionCodeToUse, sessionPasswordToUse);
+            currentManagerSessionId = assembled.sessionId;
+            await saveSessionForRoot(sessionCodeToUse, sessionPasswordToUse, currentManagerSessionId);
         }
         currentSessionCode = sessionCodeToUse;
         currentSessionPassword = sessionPasswordToUse;

package/package.json

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