@sumicom/quicksave 0.8.0 → 0.8.2

package/dist/handlers/messageHandler.js

@@ -7,18 +7,53 @@ import { CommitSummaryStateStore } from '../ai/commitSummaryStore.js';
 import { SessionManager } from '../ai/sessionManager.js';
 import { ClaudeCodeProvider } from '../ai/claudeCodeProvider.js';
 import { CodexSdkProvider } from '../ai/codexSdkProvider.js';
+import { CodexLoginManager } from '../ai/codexLogin.js';
+import { getTerminalManager } from '../terminal/terminalManager.js';
+import { getFileBrowser } from '../files/fileBrowser.js';
 import { getSessionRegistry } from '../ai/sessionRegistry.js';
 import { enrichEntry } from '../ai/enrichEntry.js';
 import { getEventStore } from '../storage/eventStore.js';
 import { readdir, stat, readFile } from 'fs/promises';
-import { existsSync } from 'fs';
+import { existsSync, watch as fsWatch } from 'fs';
 import { join, dirname, basename } from 'path';
 import { homedir } from 'os';
 const VERSION_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000; // 12 hours
-const CODEX_MODELS_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000; // 12 hours
+// Local file read is essentially free + fs.watch invalidates on cache writes.
+// 5 min is just a safety net for missed-event cases (NFS, container fs, etc.).
+const CODEX_MODELS_FILE_TTL_MS = 5 * 60 * 1000;
+// API path hits OpenAI; keep its own longer TTL to avoid hammering the
+// endpoint when the user has no local Codex CLI cache file at all.
+const CODEX_MODELS_API_TTL_MS = 60 * 60 * 1000;
+// fs.watch on ~/.codex fires multiple events per write (rename + change on
+// many filesystems). Coalesce into one refresh per burst.
+const CODEX_MODELS_WATCH_DEBOUNCE_MS = 500;
+function codexModelListsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i].id !== b[i].id || a[i].name !== b[i].name)
+            return false;
+        const aE = a[i].reasoningEfforts;
+        const bE = b[i].reasoningEfforts;
+        if (aE === bE)
+            continue;
+        if (!aE || !bE)
+            return false;
+        if (aE.length !== bE.length)
+            return false;
+        for (let j = 0; j < aE.length; j++)
+            if (aE[j] !== bE[j])
+                return false;
+    }
+    return true;
+}
 export class MessageHandler {
     repos;
-    agentVersion = '0.8.0';
+    agentVersion = '0.8.2';
     defaultRepoPath;
     clientRepos = new Map(); // peerAddress -> repoPath
     repoLocks = new Map(); // repoPath -> peerAddress holding lock
@@ -38,9 +73,15 @@ export class MessageHandler {
     versionCheckInFlight = null;
     codexModelsCache = null;
     codexModelsCheckInFlight = null;
+    codexModelsUpdateHandler = null;
+    codexModelsWatcher = null;
+    codexModelsWatchDebounce = null;
+    /** Override for tests; defaults to `~/.codex`. */
+    codexCacheDir;
+    codexLoginManager = new CodexLoginManager();
     onHistoryUpdated;
     productionBuild;
-    constructor(repos, _license, codingPaths, productionBuild = false) {
+    constructor(repos, _license, codingPaths, productionBuild = false, options) {
         this.repos = new Map();
         for (const repo of repos) {
             this.repos.set(repo.path, new GitOperations(repo.path));
@@ -48,6 +89,7 @@ export class MessageHandler {
         this.availableRepos = repos;
         this.defaultRepoPath = repos.length > 0 ? repos[0].path : '';
         this.productionBuild = productionBuild;
+        this.codexCacheDir = options?.codexCacheDir ?? join(homedir(), '.codex');
         // Load explicit coding paths only (repos and coding paths are independent)
         if (codingPaths) {
             for (const p of codingPaths) {
@@ -92,48 +134,46 @@ export class MessageHandler {
         return this.versionCheckInFlight;
     }
     /**
-     * Fetch available Codex models from OpenAI /v1/models. Reads API key from
-     * ~/.codex/auth.json (ChatGPT OAuth token or OPENAI_API_KEY). Cached for 12h
-     * with concurrent-request dedup — same pattern as checkLatestVersion.
+     * Resolve the Codex model list for the current user.
+     *
+     * Priority:
+     *   1. `~/.codex/models_cache.json` — the Codex CLI's own cache of
+     *      models the signed-in account can actually use. This is the
+     *      authoritative list for ChatGPT-OAuth logins (the common case)
+     *      and is kept fresh by the CLI itself. Reads are essentially free,
+     *      so we use a short 5min in-memory TTL — and `startCodexModelsWatcher`
+     *      invalidates the cache the moment the file is rewritten.
+     *   2. `OPENAI_API_KEY` env var + OpenAI `/v1/models` — fallback for
+     *      API-key users, who are rare but still supported. Held to a 1h
+     *      sub-TTL so we don't hammer OpenAI when the local cache is absent.
+     *
+     * Returns `null` when neither source is available (not logged in and no
+     * API key set). Concurrent calls are deduped.
      */
     async fetchCodexModels(force = false) {
-        if (!force && this.codexModelsCache &&
-            Date.now() - this.codexModelsCache.checkedAt < CODEX_MODELS_CHECK_INTERVAL_MS) {
-            return this.codexModelsCache.models;
+        if (!force && this.codexModelsCache) {
+            const ttl = this.codexModelsCache.source === 'file'
+                ? CODEX_MODELS_FILE_TTL_MS
+                : CODEX_MODELS_API_TTL_MS;
+            if (Date.now() - this.codexModelsCache.checkedAt < ttl) {
+                return this.codexModelsCache.models;
+            }
         }
         if (this.codexModelsCheckInFlight)
             return this.codexModelsCheckInFlight;
         this.codexModelsCheckInFlight = (async () => {
             try {
-                // Resolve API key: env var first, then ~/.codex/auth.json
-                let apiKey = process.env.OPENAI_API_KEY;
-                if (!apiKey) {
-                    try {
-                        const authPath = join(homedir(), '.codex', 'auth.json');
-                        const raw = await readFile(authPath, 'utf-8');
-                        const auth = JSON.parse(raw);
-                        apiKey = auth.OPENAI_API_KEY || auth.tokens?.access_token;
-                    }
-                    catch { /* no auth file */ }
+                const fromCache = await this.readCodexModelsCacheFile();
+                if (fromCache && fromCache.length > 0) {
+                    this.codexModelsCache = { models: fromCache, checkedAt: Date.now(), source: 'file' };
+                    return fromCache;
                 }
-                if (!apiKey)
-                    return null;
-                const res = await fetch('https://api.openai.com/v1/models', {
-                    headers: { Authorization: `Bearer ${apiKey}` },
-                    signal: AbortSignal.timeout(10_000),
-                });
-                if (!res.ok)
-                    return null;
-                const data = await res.json();
-                if (!Array.isArray(data.data))
-                    return null;
-                // Filter to chat-capable models (gpt-*, o*) and sort descending
-                const models = data.data
-                    .filter((m) => /^(gpt-|o\d)/.test(m.id))
-                    .map((m) => ({ id: m.id, name: m.id }))
-                    .sort((a, b) => b.id.localeCompare(a.id));
-                this.codexModelsCache = { models, checkedAt: Date.now() };
-                return models;
+                const fromApi = await this.fetchCodexModelsFromOpenAI();
+                if (fromApi && fromApi.length > 0) {
+                    this.codexModelsCache = { models: fromApi, checkedAt: Date.now(), source: 'api' };
+                    return fromApi;
+                }
+                return null;
             }
             catch {
                 return null;
@@ -144,6 +184,141 @@ export class MessageHandler {
         })();
         return this.codexModelsCheckInFlight;
     }
+    /** Snapshot accessor for the bus `/codex/models` subscription. */
+    getCachedCodexModels() {
+        return this.codexModelsCache?.models ?? [];
+    }
+    /**
+     * Wire the daemon's bus broadcast for unsolicited model-list pushes.
+     * Called once during daemon boot; the watcher invokes this on cache change.
+     */
+    setCodexModelsUpdateHandler(handler) {
+        this.codexModelsUpdateHandler = handler;
+    }
+    /**
+     * Watch the Codex CLI cache directory and refresh the in-memory model list
+     * the moment the CLI rewrites it (typically after a `codex` startup or
+     * upgrade). Tolerant of a missing `~/.codex` directory — falls back to TTL
+     * alone if the watch can't be set up. Idempotent.
+     */
+    startCodexModelsWatcher() {
+        if (this.codexModelsWatcher)
+            return;
+        // Prime the in-memory cache so the first /codex/models subscriber gets a
+        // populated snapshot instead of an empty one (the handshake also fires
+        // this; dedup via codexModelsCheckInFlight makes it cheap).
+        void this.fetchCodexModels().catch(() => { });
+        try {
+            // Watch the directory rather than the file directly so we react to
+            // first-time creation too. Many editors / cli tools rewrite atomically
+            // (write tmp + rename), which fires events for the directory, not the
+            // old file inode.
+            this.codexModelsWatcher = fsWatch(this.codexCacheDir, (_event, filename) => {
+                if (filename && filename !== 'models_cache.json')
+                    return;
+                this.scheduleCodexModelsRefresh();
+            });
+        }
+        catch {
+            // Directory missing or unwatchable — quietly skip; the 5min TTL still
+            // catches the next refresh once a request comes in.
+        }
+    }
+    /** Tear down the fs.watch handle (test cleanup). */
+    stopCodexModelsWatcher() {
+        if (this.codexModelsWatchDebounce) {
+            clearTimeout(this.codexModelsWatchDebounce);
+            this.codexModelsWatchDebounce = null;
+        }
+        if (this.codexModelsWatcher) {
+            this.codexModelsWatcher.close();
+            this.codexModelsWatcher = null;
+        }
+    }
+    scheduleCodexModelsRefresh() {
+        if (this.codexModelsWatchDebounce)
+            clearTimeout(this.codexModelsWatchDebounce);
+        this.codexModelsWatchDebounce = setTimeout(() => {
+            this.codexModelsWatchDebounce = null;
+            void this.refreshCodexModelsAndPublish();
+        }, CODEX_MODELS_WATCH_DEBOUNCE_MS);
+    }
+    async refreshCodexModelsAndPublish() {
+        const before = this.codexModelsCache?.models;
+        const after = await this.fetchCodexModels(/* force */ true);
+        if (!after)
+            return;
+        if (codexModelListsEqual(before, after))
+            return;
+        this.codexModelsUpdateHandler?.(after);
+    }
+    /**
+     * Read models from the Codex CLI's local cache. File shape (as of codex
+     * CLI v0.125): `{ models: [{ slug, display_name, visibility, supported_in_api, ... }] }`.
+     * We surface only entries that are listable and API-supported, so hidden
+     * internal models (e.g. `codex-auto-review`) don't leak into the picker.
+     */
+    async readCodexModelsCacheFile() {
+        try {
+            const cachePath = join(this.codexCacheDir, 'models_cache.json');
+            const raw = await readFile(cachePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed.models))
+                return null;
+            const models = parsed.models
+                .filter((m) => m.slug && m.visibility === 'list' && m.supported_in_api !== false)
+                .map((m) => ({ id: m.slug, name: m.display_name || m.slug }));
+            return models;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Fallback for API-key users (no ChatGPT OAuth). */
+    async fetchCodexModelsFromOpenAI() {
+        const apiKey = process.env.OPENAI_API_KEY;
+        if (!apiKey)
+            return null;
+        try {
+            const res = await fetch('https://api.openai.com/v1/models', {
+                headers: { Authorization: `Bearer ${apiKey}` },
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!res.ok)
+                return null;
+            const data = await res.json();
+            if (!Array.isArray(data.data))
+                return null;
+            return data.data
+                .filter((m) => /^(gpt-|o\d)/.test(m.id))
+                .map((m) => ({ id: m.id, name: m.id }))
+                .sort((a, b) => b.id.localeCompare(a.id));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Best-effort check for whether the local Codex CLI has valid auth.
+     * Matches how `fetchCodexModels` resolves credentials, so the PWA can
+     * prompt for login when this returns false. Does not validate the
+     * token — just checks that a credential source exists.
+     */
+    async getCodexLoginStatus() {
+        if (process.env.OPENAI_API_KEY)
+            return { loggedIn: true, method: 'api-key' };
+        try {
+            const authPath = join(this.codexCacheDir, 'auth.json');
+            const raw = await readFile(authPath, 'utf-8');
+            const auth = JSON.parse(raw);
+            if (auth.OPENAI_API_KEY)
+                return { loggedIn: true, method: 'api-key' };
+            if (auth.tokens?.access_token)
+                return { loggedIn: true, method: 'chatgpt' };
+        }
+        catch { /* no auth file */ }
+        return { loggedIn: false };
+    }
     addRepo(repo) {
         if (this.repos.has(repo.path))
             return;
@@ -159,6 +334,12 @@ export class MessageHandler {
         if (this.defaultRepoPath === path) {
             this.defaultRepoPath = this.availableRepos.length > 0 ? this.availableRepos[0].path : '';
         }
+        // Drop stale per-peer pins to this path so the next handshake-ack
+        // doesn't return a deleted repo.
+        for (const [peer, repo] of this.clientRepos) {
+            if (repo === path)
+                this.clientRepos.delete(peer);
+        }
     }
     getClientRepoPath(peerAddress) {
         return this.clientRepos.get(peerAddress) || this.defaultRepoPath;
@@ -185,7 +366,14 @@ export class MessageHandler {
         }
     }
     removeClient(peerAddress) {
-        this.clientRepos.delete(peerAddress);
+        // Intentionally keep `clientRepos[peer]`: peer identity is a stable
+        // public key, and the PWA keeps its selected repo across reconnects
+        // (e.g., background → resume). Clearing would force the next
+        // handshake-ack to return `defaultRepoPath`, which the PWA would then
+        // hydrate into gitStore before its post-reconnect `agent:switch-repo`
+        // can land — racing `git:status` requests stamped with the default
+        // path would pass the REPO_MISMATCH guard and paint the default
+        // repo's (typically clean) status over the user's real repo view.
         for (const [repoPath, holder] of this.repoLocks) {
             if (holder === peerAddress) {
                 this.repoLocks.delete(repoPath);
@@ -195,6 +383,7 @@ export class MessageHandler {
         // They persist until the user reconnects and explicitly responds.
     }
     cleanup() {
+        this.stopCodexModelsWatcher();
         this.claudeService.cleanup();
     }
     getActiveSessionCount() {
@@ -227,7 +416,9 @@ export class MessageHandler {
         return this.aiService;
     }
     async handleMessage(message, peerAddress = 'default') {
-        const isVerbose = message.type.startsWith('claude:') || message.type.startsWith('agent:add');
+        const isVerbose = message.type.startsWith('claude:') ||
+            message.type.startsWith('agent:add') ||
+            message.type.startsWith('project:');
         if (isVerbose) {
             console.log(`[msg] ${message.type} from ${peerAddress.slice(0, 12)}`);
         }
@@ -330,6 +521,12 @@ export class MessageHandler {
                 return this.handleAgentRestart(message);
             case 'codex:list-models':
                 return this.handleCodexListModels(message);
+            case 'codex:login-start':
+                return this.handleCodexLoginStart(message);
+            case 'codex:login-status':
+                return this.handleCodexLoginStatus(message);
+            case 'codex:login-cancel':
+                return this.handleCodexLoginCancel(message);
             // Claude Code SDK
             case 'claude:start':
                 return this.handleClaudeStart(message, peerAddress);
@@ -365,6 +562,20 @@ export class MessageHandler {
                 return this.handleDeleteProject(message);
             case 'push:subscription-offer':
                 return this.handlePushSubscriptionOffer(message);
+            case 'terminal:create':
+                return this.handleTerminalCreate(message);
+            case 'terminal:input':
+                return this.handleTerminalInput(message);
+            case 'terminal:resize':
+                return this.handleTerminalResize(message);
+            case 'terminal:close':
+                return this.handleTerminalClose(message);
+            case 'terminal:rename':
+                return this.handleTerminalRename(message);
+            case 'files:list':
+                return this.handleFilesList(message);
+            case 'files:read':
+                return this.handleFilesRead(message);
             default:
                 return this.createErrorResponse(message.id, 'UNKNOWN_MESSAGE_TYPE', `Unknown message type: ${message.type}`);
         }
@@ -1316,17 +1527,52 @@ export class MessageHandler {
     }
     async handleCodexListModels(message) {
         try {
-            const models = await this.fetchCodexModels(/* force */ true);
-            const response = createMessage('codex:list-models:response', { models: models ?? [] });
+            const [models, auth] = await Promise.all([
+                this.fetchCodexModels(/* force */ true),
+                this.getCodexLoginStatus(),
+            ]);
+            const response = createMessage('codex:list-models:response', { models: models ?? [], loggedIn: auth.loggedIn });
             response.id = message.id;
             return response;
         }
         catch (error) {
-            const response = createMessage('codex:list-models:response', { models: [], error: error instanceof Error ? error.message : 'Failed to fetch models' });
+            const response = createMessage('codex:list-models:response', {
+                models: [],
+                error: error instanceof Error ? error.message : 'Failed to fetch models',
+                loggedIn: false,
+            });
             response.id = message.id;
             return response;
         }
     }
+    /**
+     * Kick off the Codex device-auth OAuth flow on the daemon. Returns the
+     * one-time verification URL + user code so the PWA can display them — the
+     * user typically completes this on a different device (e.g. phone).
+     */
+    async handleCodexLoginStart(message) {
+        const state = await this.codexLoginManager.start();
+        const ok = state.loggedIn || Boolean(state.userCode && state.verificationUrl);
+        const response = createMessage('codex:login-start:response', { ok, ...state });
+        response.id = message.id;
+        return response;
+    }
+    async handleCodexLoginStatus(message) {
+        const state = await this.codexLoginManager.getStatus();
+        const response = createMessage('codex:login-status:response', state);
+        response.id = message.id;
+        return response;
+    }
+    async handleCodexLoginCancel(message) {
+        this.codexLoginManager.cancel();
+        const response = createMessage('codex:login-cancel:response', { ok: true });
+        response.id = message.id;
+        return response;
+    }
+    /** Expose for the daemon to wire login-state updates into bus broadcasts. */
+    getCodexLoginManager() {
+        return this.codexLoginManager;
+    }
     // ============================================================================
     // Claude Code SDK Handlers
     // ============================================================================
@@ -1623,19 +1869,24 @@ export class MessageHandler {
         const repos = [];
         const seen = new Set();
         try {
-            // 1. Check if cwd itself is a git repo
-            const rootBranch = await this.getGitBranchQuiet(cwd);
-            if (rootBranch !== undefined) {
+            // 1. Check if cwd itself is a git repo. Use the cheap fs check rather
+            // than spawning `git branch -a` so a transient git failure (EAGAIN
+            // under daemon load, refs being rewritten by a concurrent fetch/gc,
+            // detached HEAD returning empty `current`) doesn't drop the root
+            // and make the PWA's Git section flash empty. Branch + dirty are
+            // filled in best-effort below; undefined just means "unknown".
+            const isRootRepo = existsSync(join(cwd, '.git'));
+            if (isRootRepo) {
                 repos.push({
                     path: cwd,
                     name: basename(cwd),
-                    currentBranch: rootBranch || undefined,
+                    currentBranch: (await this.getGitBranchQuiet(cwd)) || undefined,
                     hasChanges: await this.getGitDirtyQuiet(cwd),
                 });
                 seen.add(cwd);
             }
             // 2. Find submodules via git
-            if (rootBranch !== undefined) {
+            if (isRootRepo) {
                 try {
                     const git = new GitOperations(cwd);
                     const submodules = await git.getSubmodules();
@@ -1708,15 +1959,27 @@ export class MessageHandler {
         return response;
     }
     /**
-     * Hide a project without touching the filesystem. Archives every active
-     * session under `cwd` (each archive fires `/sessions/history` so PWAs drop
-     * the sessions from their live view) and removes the cwd from managed
+     * Hide a project without touching the filesystem. Closes every live
+     * Claude session under `cwd` (so a stray resume can't re-materialize an
+     * active registry entry — see note below), archives every registry entry
+     * under `cwd` (each archive fires `/sessions/history` so PWAs drop the
+     * sessions from their live view), and removes the cwd from managed
      * coding paths so it stops surfacing as an empty workspace. Archived
      * session JSON stays on disk and can be restored individually.
+     *
+     * Why close live sessions first: `handleClaudeResume` builds a fresh
+     * active registry entry when `getEntry` returns undefined (archived
+     * entries aren't in memory). Without this step, any subsequent resume
+     * of a still-running session re-creates the active entry and the
+     * project reappears on the next project:list-summaries.
      */
     handleDeleteProject(message) {
         const { cwd } = message.payload;
         const registry = getSessionRegistry();
+        const liveHere = this.claudeService.getActiveSessions().filter((s) => s.cwd === cwd);
+        for (const s of liveHere) {
+            this.claudeService.closeSession(s.sessionId);
+        }
         const active = registry.getEntriesForProject(cwd);
         let archivedCount = 0;
         for (const entry of active) {
@@ -1726,10 +1989,12 @@ export class MessageHandler {
                 this.onHistoryUpdated?.(cwd, updated, 'upsert');
             }
         }
-        if (this.codingPaths.has(cwd)) {
+        const hadCodingPath = this.codingPaths.has(cwd);
+        if (hadCodingPath) {
             this.codingPaths.delete(cwd);
             removeManagedCodingPath(cwd);
         }
+        console.log(`[project:delete] cwd=${cwd} closedSessions=${liveHere.length} archived=${archivedCount} removedCodingPath=${hadCodingPath}`);
         const response = createMessage('project:delete:response', { success: true, archivedCount });
         response.id = message.id;
         return response;
@@ -1774,6 +2039,100 @@ export class MessageHandler {
         response.id = message.id;
         return response;
     }
+    // ── Terminal (PTY) handlers ──────────────────────────────────────────────
+    async handleTerminalCreate(message) {
+        let payload;
+        try {
+            const summary = await getTerminalManager().create(message.payload);
+            payload = { success: true, terminal: summary };
+        }
+        catch (err) {
+            payload = {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        const response = createMessage('terminal:create:response', payload);
+        response.id = message.id;
+        return response;
+    }
+    async handleTerminalInput(message) {
+        let payload;
+        try {
+            getTerminalManager().write(message.payload.terminalId, message.payload.data);
+            payload = { success: true };
+        }
+        catch (err) {
+            payload = {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        const response = createMessage('terminal:input:response', payload);
+        response.id = message.id;
+        return response;
+    }
+    async handleTerminalResize(message) {
+        let payload;
+        try {
+            getTerminalManager().resize(message.payload.terminalId, message.payload.cols, message.payload.rows);
+            payload = { success: true };
+        }
+        catch (err) {
+            payload = {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        const response = createMessage('terminal:resize:response', payload);
+        response.id = message.id;
+        return response;
+    }
+    async handleTerminalClose(message) {
+        let payload;
+        try {
+            getTerminalManager().close(message.payload.terminalId, message.payload.force ?? false);
+            payload = { success: true };
+        }
+        catch (err) {
+            payload = {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        const response = createMessage('terminal:close:response', payload);
+        response.id = message.id;
+        return response;
+    }
+    async handleTerminalRename(message) {
+        let payload;
+        try {
+            const summary = getTerminalManager().rename(message.payload.terminalId, message.payload.title);
+            payload = { success: true, terminal: summary };
+        }
+        catch (err) {
+            payload = {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+        const response = createMessage('terminal:rename:response', payload);
+        response.id = message.id;
+        return response;
+    }
+    // ── File browser handlers ────────────────────────────────────────────────
+    async handleFilesList(message) {
+        const payload = await getFileBrowser().list(message.payload);
+        const response = createMessage('files:list:response', payload);
+        response.id = message.id;
+        return response;
+    }
+    async handleFilesRead(message) {
+        const payload = await getFileBrowser().read(message.payload);
+        const response = createMessage('files:read:response', payload);
+        response.id = message.id;
+        return response;
+    }
     createErrorResponse(id, code, message) {
         const response = createMessage('error', { code, message });
         response.id = id;