tabminal 3.0.13 → 3.0.15

package/src/acp-manager.mjs

@@ -16,6 +16,11 @@ const DEFAULT_TERMINAL_OUTPUT_LIMIT = 256 * 1024;
 const DEFAULT_AVAILABILITY_OVERRIDE_TTL_MS = 30 * 1000;
 const DEFAULT_PROBE_CACHE_TTL_MS = 15 * 1000;
 const DEFAULT_TRANSCRIPT_PERSIST_DELAY_MS = 250;
+const ALL_SESSION_AGENT_IDS = new Set([
+    'claude',
+    'codex',
+    'copilot'
+]);
 const TEXT_ATTACHMENT_EXTENSIONS = new Set([
     'txt', 'md', 'markdown', 'json', 'jsonl', 'yaml', 'yml', 'toml',
     'ini', 'env', 'xml', 'html', 'htm', 'css', 'scss', 'less', 'csv',
@@ -104,7 +109,8 @@ function buildAgentConfigSummary(agentId, config = {}) {
 
 function normalizeAgentSessionCapabilities(
     agentCapabilities = null,
-    connection = null
+    connection = null,
+    definitionId = ''
 ) {
     const sessionCapabilities = (
         agentCapabilities?.sessionCapabilities
@@ -121,6 +127,11 @@ function normalizeAgentSessionCapabilities(
             sessionCapabilities?.list
             && typeof connection?.listSessions === 'function'
         ),
+        listAll: !!(
+            sessionCapabilities?.list
+            && typeof connection?.listSessions === 'function'
+            && ALL_SESSION_AGENT_IDS.has(String(definitionId || '').trim())
+        ),
         resume: !!(
             sessionCapabilities?.resume
             && typeof connection?.unstable_resumeSession === 'function'
@@ -1514,17 +1525,23 @@ class AcpRuntime extends EventEmitter {
     #getSessionCapabilities() {
         const capabilities = normalizeAgentSessionCapabilities(
             this.agentCapabilities,
-            this.connection
+            this.connection,
+            this.definition?.id
         );
         if (
             this.definition?.id === 'gemini'
             && this.#supportsGeminiCliSessionListing()
         ) {
             capabilities.list = true;
+            capabilities.listAll = false;
         }
         return capabilities;
     }
 
+    getSessionCapabilities() {
+        return { ...this.#getSessionCapabilities() };
+    }
+
     #supportsGeminiCliSessionListing() {
         if (this.definition?.id !== 'gemini') return false;
         const command = this.definition.command;
@@ -1577,6 +1594,32 @@ class AcpRuntime extends EventEmitter {
         }));
     }
 
+    #supportsAllSessionListing() {
+        return !!(
+            this.#getSessionCapabilities().listAll
+            && typeof this.connection?.listSessions === 'function'
+        );
+    }
+
+    async #listSessionsViaConnection(options = {}) {
+        const response = await this.connection.listSessions({
+            cwd: options.all ? null : (options.cwd || this.cwd),
+            cursor: options.cursor || null
+        });
+        return {
+            sessions: Array.isArray(response?.sessions)
+                ? response.sessions
+                    .map(normalizeListedSessionInfo)
+                    .filter(
+                        (session) => session.sessionId && session.cwd
+                    )
+                : [],
+            nextCursor: typeof response?.nextCursor === 'string'
+                ? response.nextCursor
+                : ''
+        };
+    }
+
     #resolveAvailableModes(availableModes, existingModes = []) {
         if (Array.isArray(availableModes) && availableModes.length > 0) {
             this.cachedAvailableModes = availableModes;
@@ -2023,27 +2066,24 @@ class AcpRuntime extends EventEmitter {
         this.clearIdleShutdown();
 
         const sessionCapabilities = this.#getSessionCapabilities();
+        const wantsAll = !!options.all;
         if (
             sessionCapabilities.list
             && typeof this.connection?.listSessions === 'function'
         ) {
+            if (wantsAll && this.#supportsAllSessionListing()) {
+                return await this.#listSessionsViaConnection({
+                    cwd: options.cwd || this.cwd,
+                    cursor: options.cursor || '',
+                    all: true
+                });
+            }
             try {
-                const response = await this.connection.listSessions({
+                return await this.#listSessionsViaConnection({
                     cwd: options.cwd || this.cwd,
-                    cursor: options.cursor || null
+                    cursor: options.cursor || '',
+                    all: false
                 });
-                return {
-                    sessions: Array.isArray(response?.sessions)
-                        ? response.sessions
-                            .map(normalizeListedSessionInfo)
-                            .filter(
-                                (session) => session.sessionId && session.cwd
-                            )
-                        : [],
-                    nextCursor: typeof response?.nextCursor === 'string'
-                        ? response.nextCursor
-                        : ''
-                };
             } catch (error) {
                 const message = String(error?.message || '');
                 const canFallbackToCli = this.#supportsGeminiCliSessionListing();
@@ -3391,7 +3431,8 @@ export class AcpManager {
 
         const sessionCapabilities = normalizeAgentSessionCapabilities(
             runtime?.agentCapabilities,
-            runtime?.connection
+            runtime?.connection,
+            runtime?.definition?.id
         );
         const hasSessionCapabilities = serialized.sessionCapabilities
             && typeof serialized.sessionCapabilities === 'object';
@@ -3671,11 +3712,19 @@ export class AcpManager {
         const cwd = path.resolve(options.cwd || process.cwd());
         const { runtimeEntry, createdRuntime, runtimeStoreKey } =
             this.#ensureRuntimeEntry(definition, cwd);
+        const cursor = typeof options.cursor === 'string' ? options.cursor : '';
+        const sessionCapabilities = (
+            typeof runtimeEntry.runtime.getSessionCapabilities === 'function'
+                ? runtimeEntry.runtime.getSessionCapabilities()
+                : {}
+        );
+        const canListAll = !!(options.all && sessionCapabilities.listAll);
 
         try {
             const result = await runtimeEntry.runtime.listSessions({
                 cwd,
-                cursor: typeof options.cursor === 'string' ? options.cursor : ''
+                all: canListAll,
+                cursor
             });
             this.#clearDefinitionAvailabilityOverride(definition.id);
             if (runtimeEntry.runtime.tabs.size === 0) {
@@ -3696,6 +3745,119 @@ export class AcpManager {
         }
     }
 
+    async listResumeSessions(options) {
+        await this.ensureConfigsLoaded();
+        const definition = this.definitions.find(
+            (entry) => entry.id === options.agentId
+        );
+        if (!definition) {
+            throw new Error('Unknown agent');
+        }
+        const availability = this.getDefinitionAvailability(definition);
+        if (!availability.available) {
+            throw new Error(availability.reason || 'Agent unavailable');
+        }
+
+        const cwd = path.resolve(options.cwd || process.cwd());
+        const { runtimeEntry, createdRuntime, runtimeStoreKey } =
+            this.#ensureRuntimeEntry(definition, cwd);
+        const branchLimit = 500;
+        const mergedLimit = 300;
+
+        const listBranch = async (all) => {
+            const sessions = [];
+            let nextCursor = '';
+            const seenCursors = new Set();
+            for (;;) {
+                const result = await runtimeEntry.runtime.listSessions({
+                    cwd,
+                    all,
+                    cursor: nextCursor
+                });
+                sessions.push(...(Array.isArray(result?.sessions)
+                    ? result.sessions
+                    : []));
+                if (sessions.length >= branchLimit) {
+                    return sessions.slice(0, branchLimit);
+                }
+                const previousCursor = nextCursor;
+                nextCursor = typeof result?.nextCursor === 'string'
+                    ? result.nextCursor
+                    : '';
+                if (!nextCursor) {
+                    break;
+                }
+                if (nextCursor === previousCursor || seenCursors.has(nextCursor)) {
+                    break;
+                }
+                seenCursors.add(nextCursor);
+            }
+            return sessions;
+        };
+
+        const cwdPromise = listBranch(false);
+        const allPromise = listBranch(true);
+
+        try {
+            const settled = await Promise.allSettled([
+                cwdPromise,
+                allPromise
+            ]);
+            const cwdResult = settled[0];
+            const allResult = settled[1] || null;
+            const cwdSessions = cwdResult?.status === 'fulfilled'
+                ? cwdResult.value
+                : [];
+            const allSessions = allResult?.status === 'fulfilled'
+                && Array.isArray(allResult.value)
+                ? allResult.value
+                : [];
+
+            if (cwdSessions.length === 0 && allSessions.length === 0) {
+                throw (
+                    cwdResult?.reason
+                    || allResult?.reason
+                    || new Error('Failed to list agent sessions')
+                );
+            }
+
+            const merged = [];
+            const seen = new Set();
+            for (const session of [...cwdSessions, ...allSessions]) {
+                const sessionId = String(session?.sessionId || '').trim();
+                if (!sessionId || seen.has(sessionId)) continue;
+                seen.add(sessionId);
+                merged.push(session);
+                if (merged.length >= mergedLimit) {
+                    break;
+                }
+            }
+
+            this.#clearDefinitionAvailabilityOverride(definition.id);
+            if (runtimeEntry.runtime.tabs.size === 0) {
+                runtimeEntry.runtime.scheduleIdleShutdown(async () => {
+                    if (runtimeEntry.runtime.tabs.size > 0) return;
+                    await this.#disposeRuntimeEntry(
+                        runtimeStoreKey,
+                        runtimeEntry
+                    );
+                });
+            }
+
+            return {
+                sessions: merged,
+                scope: allResult?.status === 'fulfilled'
+                    ? 'merged'
+                    : 'cwd'
+            };
+        } catch (error) {
+            if (createdRuntime && runtimeEntry.runtime.tabs.size === 0) {
+                await this.#disposeRuntimeEntry(runtimeStoreKey, runtimeEntry);
+            }
+            throw error;
+        }
+    }
+
     async resumeTab(options) {
         await this.ensureConfigsLoaded();
         const definition = this.definitions.find(

package/src/fs-routes.mjs

@@ -1,5 +1,6 @@
 import { constants as fsConstants } from 'node:fs';
 import fs from 'node:fs/promises';
+import crypto from 'node:crypto';
 import path from 'node:path';
 import process from 'node:process';
 
@@ -12,6 +13,11 @@ const IMAGE_MIME_TYPES = {
     '.webp': 'image/webp'
 };
 
+const RAW_MIME_TYPES = {
+    ...IMAGE_MIME_TYPES,
+    '.pdf': 'application/pdf'
+};
+
 export function isSupportedTextBuffer(buffer) {
     if (!Buffer.isBuffer(buffer) || buffer.length === 0) {
         return true;
@@ -45,6 +51,110 @@ export function isSupportedTextBuffer(buffer) {
     }
 }
 
+function createFsRouteError(message, status) {
+    const error = new Error(message);
+    error.status = status;
+    return error;
+}
+
+function normalizeFsRouteError(error, fallbackMessage = 'File system error') {
+    if (error?.status) {
+        return error;
+    }
+
+    if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') {
+        const notFoundError = createFsRouteError('File not found', 404);
+        notFoundError.code = 'file-not-found';
+        return notFoundError;
+    }
+
+    if (error?.code === 'EISDIR') {
+        return createFsRouteError('Not a file', 400);
+    }
+
+    const normalizedError = createFsRouteError(
+        error?.message || fallbackMessage,
+        500
+    );
+    if (error?.code) {
+        normalizedError.code = error.code;
+    }
+    return normalizedError;
+}
+
+export function buildTextFileVersion(buffer) {
+    return crypto
+        .createHash('sha256')
+        .update(buffer)
+        .digest('hex');
+}
+
+async function canWriteExistingFile(targetPath) {
+    try {
+        const handle = await fs.open(targetPath, 'r+');
+        await handle.close();
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export async function readTextFileSnapshot(fullPath) {
+    try {
+        const stats = await fs.stat(fullPath);
+
+        if (!stats.isFile()) {
+            throw createFsRouteError('Not a file', 400);
+        }
+
+        if (stats.size > 1024 * 1024 * 5) {
+            throw createFsRouteError('File too large', 400);
+        }
+
+        const contentBuffer = await fs.readFile(fullPath);
+        if (!isSupportedTextBuffer(contentBuffer)) {
+            const error = createFsRouteError('Unsupported file type', 415);
+            error.code = 'unsupported-file-type';
+            throw error;
+        }
+
+        const decoder = new TextDecoder('utf-8', { fatal: true });
+        const content = decoder.decode(contentBuffer);
+
+        return {
+            content,
+            readonly: !(await canWriteExistingFile(fullPath)),
+            version: buildTextFileVersion(contentBuffer),
+            size: stats.size,
+            mtimeMs: stats.mtimeMs
+        };
+    } catch (error) {
+        throw normalizeFsRouteError(error, 'Unable to read file');
+    }
+}
+
+export async function writeTextFileSnapshot(
+    fullPath,
+    content,
+    expectedVersion = '',
+    force = false
+) {
+    const current = await readTextFileSnapshot(fullPath);
+    if (
+        !force
+        && expectedVersion
+        && expectedVersion !== current.version
+    ) {
+        const error = createFsRouteError('File version conflict', 409);
+        error.code = 'file-version-conflict';
+        error.snapshot = current;
+        throw error;
+    }
+
+    await fs.writeFile(fullPath, content, 'utf8');
+    return await readTextFileSnapshot(fullPath);
+}
+
 function joinRelativePath(basePath, name) {
     if (!basePath || basePath === '.' || basePath === path.sep) {
         return name;
@@ -325,50 +435,49 @@ export const setupFsRoutes = (router) => {
 
         try {
             const fullPath = resolvePath(baseDir, filePath);
-            const stats = await fs.stat(fullPath);
-
-            if (!stats.isFile()) {
-                ctx.status = 400;
-                ctx.body = { error: 'Not a file' };
-                return;
-            }
-
-            if (stats.size > 1024 * 1024 * 5) { // 5MB limit for now
-                ctx.status = 400;
-                ctx.body = { error: 'File too large' };
-                return;
-            }
-
-            const contentBuffer = await fs.readFile(fullPath);
-            if (!isSupportedTextBuffer(contentBuffer)) {
-                ctx.status = 415;
-                ctx.body = {
-                    error: 'Unsupported file type',
-                    code: 'unsupported-file-type'
-                };
-                return;
+            ctx.body = await readTextFileSnapshot(fullPath);
+        } catch (err) {
+            if ((err?.status || 500) >= 500) {
+                console.error('FS Read Error:', err);
             }
+            ctx.status = err?.status || 500;
+            ctx.body = {
+                error: err.message,
+                ...(err?.code ? { code: err.code } : {})
+            };
+        }
+    });
 
-            const decoder = new TextDecoder('utf-8', { fatal: true });
-            const content = decoder.decode(contentBuffer);
-            
-            let readonly = false;
-            try {
-                const handle = await fs.open(fullPath, 'r+');
-                await handle.close();
-            } catch {
-                readonly = true;
-            }
+    router.get('/api/fs/info', async (ctx) => {
+        const filePath = ctx.query.path;
+        if (!filePath) {
+            ctx.status = 400;
+            ctx.body = { error: 'Path required' };
+            return;
+        }
 
-            ctx.body = { content, readonly };
+        try {
+            const fullPath = resolvePath(baseDir, filePath);
+            const snapshot = await readTextFileSnapshot(fullPath);
+            ctx.body = {
+                readonly: snapshot.readonly,
+                version: snapshot.version,
+                size: snapshot.size,
+                mtimeMs: snapshot.mtimeMs
+            };
         } catch (err) {
-            console.error('FS Read Error:', err);
-            ctx.status = 500;
-            ctx.body = { error: err.message };
+            if ((err?.status || 500) >= 500) {
+                console.error('FS Info Error:', err);
+            }
+            ctx.status = err?.status || 500;
+            ctx.body = {
+                error: err.message,
+                ...(err?.code ? { code: err.code } : {})
+            };
         }
     });
 
-    // Raw file access (for images)
+    // Raw file access (for previews like images and PDFs)
     router.get('/api/fs/raw', async (ctx) => {
         const filePath = ctx.query.path;
         if (!filePath) {
@@ -380,8 +489,8 @@ export const setupFsRoutes = (router) => {
             const fullPath = resolvePath(baseDir, filePath);
             const ext = path.extname(fullPath).toLowerCase();
 
-            if (IMAGE_MIME_TYPES[ext]) {
-                ctx.type = IMAGE_MIME_TYPES[ext];
+            if (RAW_MIME_TYPES[ext]) {
+                ctx.type = RAW_MIME_TYPES[ext];
                 ctx.body = await fs.readFile(fullPath);
             } else {
                 ctx.status = 400;

package/src/server.mjs

@@ -19,7 +19,10 @@ import { AcpManager } from './acp-manager.mjs';
 import { SystemMonitor } from './system-monitor.mjs';
 import { config } from './config.mjs';
 import { authMiddleware, verifyClient } from './auth.mjs';
-import { setupFsRoutes } from './fs-routes.mjs';
+import {
+    setupFsRoutes,
+    writeTextFileSnapshot
+} from './fs-routes.mjs';
 import * as persistence from './persistence.mjs';
 import { alan, network, web } from 'utilitas';
 
@@ -171,6 +174,22 @@ router.get('/healthz', (ctx) => {
     ctx.body = { status: 'ok' };
 });
 
+app.use(async (ctx, next) => {
+    if (ctx.method === 'GET' && ctx.path === '/api/version') {
+        ctx.set(
+            'Cache-Control',
+            'no-store, no-cache, must-revalidate, proxy-revalidate'
+        );
+        ctx.set('Pragma', 'no-cache');
+        ctx.set('Expires', '0');
+        ctx.body = {
+            bootId: SERVER_BOOT_ID
+        };
+        return;
+    }
+    await next();
+});
+
 // Serve static files (public) BEFORE auth middleware
 app.use(serve(publicDir));
 
@@ -206,6 +225,7 @@ setupFsRoutes(router);
 
 // API routes for session management
 router.all('/api/heartbeat', async (ctx) => {
+    const fileWriteResults = [];
     if (ctx.method === 'POST') {
         const { updates } = ctx.request.body;
         if (updates && updates.sessions) {
@@ -223,13 +243,50 @@ router.all('/api/heartbeat', async (ctx) => {
                         });
                     }
                     if (update.fileWrites) {
+                        const sessionResults = [];
                         for (const file of update.fileWrites) {
                             try {
-                                await fsPromises.writeFile(file.path, file.content);
+                                const snapshot = await writeTextFileSnapshot(
+                                    file.path,
+                                    file.content,
+                                    file.expectedVersion,
+                                    file.force === true
+                                );
+                                sessionResults.push({
+                                    path: file.path,
+                                    status: 'ok',
+                                    version: snapshot.version,
+                                    readonly: snapshot.readonly
+                                });
                             } catch (e) {
-                                console.error(`[Heartbeat] Write failed: ${file.path}`, e);
+                                if (e?.status === 409) {
+                                    sessionResults.push({
+                                        path: file.path,
+                                        status: 'conflict',
+                                        version: e.snapshot?.version || '',
+                                        content: e.snapshot?.content || '',
+                                        readonly: !!e.snapshot?.readonly,
+                                        error: e.message
+                                    });
+                                    continue;
+                                }
+                                console.error(
+                                    `[Heartbeat] Write failed: ${file.path}`,
+                                    e
+                                );
+                                sessionResults.push({
+                                    path: file.path,
+                                    status: 'error',
+                                    error: e?.message || 'Write failed'
+                                });
                             }
                         }
+                        if (sessionResults.length > 0) {
+                            fileWriteResults.push({
+                                id: update.id,
+                                fileWrites: sessionResults
+                            });
+                        }
                     }
                 }
             }
@@ -239,6 +296,7 @@ router.all('/api/heartbeat', async (ctx) => {
     ctx.body = {
         sessions: terminalManager.listSessions(),
         agents: await acpManager.listInventory(),
+        fileWriteResults,
         system: systemMonitor.getStats(),
         runtime: {
             bootId: SERVER_BOOT_ID
@@ -344,7 +402,7 @@ router.get('/api/agents', async (ctx) => {
 });
 
 router.get('/api/agents/sessions', async (ctx) => {
-    const { agentId = '', cwd = '', cursor = '' } = ctx.query || {};
+    const { agentId = '', cwd = '' } = ctx.query || {};
     if (!agentId || typeof agentId !== 'string') {
         ctx.status = 400;
         ctx.body = { error: 'agentId is required' };
@@ -357,28 +415,14 @@ router.get('/api/agents/sessions', async (ctx) => {
     }
 
     try {
-        let nextCursor = typeof cursor === 'string' ? cursor : '';
-        const sessions = [];
-        const paginate = !!nextCursor;
-        for (let page = 0; page < 5; page += 1) {
-            const result = await acpManager.listSessions({
-                agentId,
-                cwd,
-                cursor: nextCursor
-            });
-            sessions.push(...(Array.isArray(result?.sessions)
-                ? result.sessions
-                : []));
-            nextCursor = typeof result?.nextCursor === 'string'
-                ? result.nextCursor
-                : '';
-            if (paginate || !nextCursor || sessions.length >= 50) {
-                break;
-            }
-        }
+        const result = await acpManager.listResumeSessions({
+            agentId,
+            cwd
+        });
         ctx.body = {
-            sessions: sessions.slice(0, 50),
-            nextCursor
+            sessions: Array.isArray(result?.sessions) ? result.sessions : [],
+            nextCursor: '',
+            scope: typeof result?.scope === 'string' ? result.scope : 'cwd'
         };
     } catch (error) {
         const message = error?.message || 'Failed to list agent sessions';