tabminal 2.0.14 → 2.0.16

package/src/persistence.mjs

@@ -7,6 +7,8 @@ const BASE_DIR = path.join(HOME_DIR, '.tabminal');
 const SESSIONS_DIR = path.join(BASE_DIR, 'sessions');
 const MEMORY_FILE = path.join(BASE_DIR, 'memory.json');
 const CLUSTER_FILE = path.join(BASE_DIR, 'cluster.json');
+const AGENT_TABS_FILE = path.join(BASE_DIR, 'agent-tabs.json');
+const AGENT_CONFIG_FILE = path.join(BASE_DIR, 'agent-config.json');
 const getSessionSnapshotPath = (id) => path.join(SESSIONS_DIR, `${id}.snapshot`);
 
 // Ensure directories exist
@@ -193,6 +195,157 @@ export const saveCluster = async (servers) => {
     }
 };
 
+// --- ACP Agent Tab Persistence ---
+
+function normalizeAgentTabs(tabs) {
+    if (!Array.isArray(tabs)) return [];
+    const normalized = [];
+    for (const entry of tabs) {
+        if (!entry || typeof entry !== 'object') continue;
+        const id = typeof entry.id === 'string' ? entry.id.trim() : '';
+        const agentId = typeof entry.agentId === 'string'
+            ? entry.agentId.trim()
+            : '';
+        const cwd = typeof entry.cwd === 'string' ? entry.cwd.trim() : '';
+        const acpSessionId = typeof entry.acpSessionId === 'string'
+            ? entry.acpSessionId.trim()
+            : '';
+        const terminalSessionId = typeof entry.terminalSessionId === 'string'
+            ? entry.terminalSessionId.trim()
+            : '';
+        const createdAt = typeof entry.createdAt === 'string'
+            ? entry.createdAt.trim()
+            : '';
+        const title = typeof entry.title === 'string'
+            ? entry.title
+            : '';
+        const currentModeId = typeof entry.currentModeId === 'string'
+            ? entry.currentModeId
+            : '';
+        const availableModes = Array.isArray(entry.availableModes)
+            ? entry.availableModes
+            : [];
+        const availableCommands = Array.isArray(entry.availableCommands)
+            ? entry.availableCommands
+            : [];
+        const configOptions = Array.isArray(entry.configOptions)
+            ? entry.configOptions
+            : [];
+        const messages = Array.isArray(entry.messages)
+            ? entry.messages
+            : [];
+        const toolCalls = Array.isArray(entry.toolCalls)
+            ? entry.toolCalls
+            : [];
+        const permissions = Array.isArray(entry.permissions)
+            ? entry.permissions
+            : [];
+        const plan = Array.isArray(entry.plan)
+            ? entry.plan
+            : [];
+        const usage = entry.usage && typeof entry.usage === 'object'
+            ? entry.usage
+            : null;
+        const terminals = Array.isArray(entry.terminals)
+            ? entry.terminals
+            : [];
+        if (!id || !agentId || !cwd || !acpSessionId) continue;
+        normalized.push({
+            id,
+            agentId,
+            cwd,
+            acpSessionId,
+            terminalSessionId,
+            createdAt,
+            title,
+            currentModeId,
+            availableModes,
+            availableCommands,
+            configOptions,
+            messages,
+            toolCalls,
+            permissions,
+            plan,
+            usage,
+            terminals
+        });
+    }
+    return normalized;
+}
+
+export const loadAgentTabs = async () => {
+    await init();
+    try {
+        const content = await fs.readFile(AGENT_TABS_FILE, 'utf-8');
+        const parsed = JSON.parse(content);
+        if (Array.isArray(parsed)) {
+            return normalizeAgentTabs(parsed);
+        }
+        return normalizeAgentTabs(parsed?.tabs);
+    } catch {
+        return [];
+    }
+};
+
+export const saveAgentTabs = async (tabs) => {
+    await init();
+    const normalized = normalizeAgentTabs(tabs);
+    const payload = { tabs: normalized };
+    try {
+        await fs.writeFile(AGENT_TABS_FILE, JSON.stringify(payload, null, 2));
+    } catch (e) {
+        console.error('[Persistence] Failed to save agent tabs:', e);
+        throw e;
+    }
+};
+
+// --- ACP Agent Config Persistence ---
+
+function normalizeAgentEnv(env) {
+    if (!env || typeof env !== 'object') return {};
+    const normalized = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof key !== 'string' || !key.trim()) continue;
+        normalized[key.trim()] = typeof value === 'string' ? value : '';
+    }
+    return normalized;
+}
+
+function normalizeAgentConfigs(configs) {
+    if (!configs || typeof configs !== 'object') return {};
+    const normalized = {};
+    for (const [agentId, entry] of Object.entries(configs)) {
+        if (typeof agentId !== 'string' || !agentId.trim()) continue;
+        normalized[agentId.trim()] = {
+            env: normalizeAgentEnv(entry?.env)
+        };
+    }
+    return normalized;
+}
+
+export const loadAgentConfigs = async () => {
+    await init();
+    try {
+        const content = await fs.readFile(AGENT_CONFIG_FILE, 'utf-8');
+        const parsed = JSON.parse(content);
+        return normalizeAgentConfigs(parsed?.agents || parsed);
+    } catch {
+        return {};
+    }
+};
+
+export const saveAgentConfigs = async (configs) => {
+    await init();
+    const normalized = normalizeAgentConfigs(configs);
+    const payload = { agents: normalized };
+    try {
+        await fs.writeFile(AGENT_CONFIG_FILE, JSON.stringify(payload, null, 2));
+    } catch (e) {
+        console.error('[Persistence] Failed to save agent configs:', e);
+        throw e;
+    }
+};
+
 // --- Raw Log Persistence ---
 
 export const appendSessionLog = async (id, chunk) => {

package/src/server.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import crypto from 'node:crypto';
 import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
@@ -10,9 +11,11 @@ import Koa from 'koa';
 import serve from 'koa-static';
 import Router from '@koa/router';
 import bodyParser from 'koa-bodyparser';
+import { formidable } from 'formidable';
 import { WebSocketServer } from 'ws';
 
 import { TerminalManager } from './terminal-manager.mjs';
+import { AcpManager } from './acp-manager.mjs';
 import { SystemMonitor } from './system-monitor.mjs';
 import { config } from './config.mjs';
 import { authMiddleware, verifyClient } from './auth.mjs';
@@ -27,12 +30,61 @@ const publicDir = path.join(__dirname, '..', 'public');
 const app = new Koa();
 const router = new Router();
 const SERVER_BOOT_ID = `${Date.now()}`;
+const AGENT_ATTACHMENT_FIELD = 'attachments';
+const MAX_AGENT_ATTACHMENTS = 8;
+const MAX_AGENT_ATTACHMENT_SIZE = 10 * 1024 * 1024;
+const MAX_AGENT_ATTACHMENTS_TOTAL_SIZE = 25 * 1024 * 1024;
+
 function debugLog(...args) {
     if (config.debug) {
         console.log(...args);
     }
 }
 
+function parseMultipartForm(req, options = {}) {
+    return new Promise((resolve, reject) => {
+        const form = formidable({
+            multiples: true,
+            allowEmptyFiles: false,
+            maxFiles: MAX_AGENT_ATTACHMENTS,
+            maxFileSize: MAX_AGENT_ATTACHMENT_SIZE,
+            maxTotalFileSize: MAX_AGENT_ATTACHMENTS_TOTAL_SIZE,
+            ...options
+        });
+        form.parse(req, (error, fields, files) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve({ fields, files });
+        });
+    });
+}
+
+function firstFormFieldValue(value) {
+    if (Array.isArray(value)) {
+        return typeof value[0] === 'string' ? value[0] : '';
+    }
+    return typeof value === 'string' ? value : '';
+}
+
+function normalizePromptAttachments(files) {
+    const rawList = Array.isArray(files)
+        ? files
+        : (files ? [files] : []);
+    return rawList
+        .filter((file) => file && typeof file === 'object')
+        .map((file) => ({
+            id: crypto.randomUUID(),
+            name: String(file.originalFilename || 'attachment').trim()
+                || 'attachment',
+            mimeType: String(file.mimetype || '').trim(),
+            size: Number.isFinite(file.size) ? file.size : 0,
+            tempPath: String(file.filepath || '').trim()
+        }))
+        .filter((file) => file.tempPath);
+}
+
 app.use(async (ctx, next) => {
     const origin = ctx.get('Origin');
     if (origin) {
@@ -130,15 +182,22 @@ app.use(authMiddleware);
 
 const systemMonitor = new SystemMonitor();
 const terminalManager = new TerminalManager();
+const acpManager = new AcpManager({ terminalManager });
 
 // Restore sessions
 (async () => {
-    const restoredSessions = await persistence.loadSessions();
-    if (restoredSessions.length > 0) {
-        console.log(`[Server] Restoring ${restoredSessions.length} sessions...`);
-        for (const data of restoredSessions) {
-            terminalManager.createSession(data);
+    acpManager.restoring = true;
+    try {
+        const restoredSessions = await persistence.loadSessions();
+        if (restoredSessions.length > 0) {
+            console.log(`[Server] Restoring ${restoredSessions.length} sessions...`);
+            for (const data of restoredSessions) {
+                terminalManager.createSession(data);
+            }
         }
+        await acpManager.restoreTabs(new Set(terminalManager.sessions.keys()));
+    } finally {
+        acpManager.restoring = false;
     }
 })();
 
@@ -201,6 +260,13 @@ router.post('/api/sessions', (ctx) => {
 
 router.delete('/api/sessions/:id', async (ctx) => {
     const { id } = ctx.params;
+    const session = terminalManager.getSession(id);
+    if (session?.managed?.kind === 'agent-terminal') {
+        await acpManager.releaseManagedTerminalSession(id, { destroy: true });
+        ctx.status = 204;
+        return;
+    }
+    await acpManager.closeTabsForTerminalSession(id);
     await terminalManager.removeSession(id);
     ctx.status = 204;
 });
@@ -269,6 +335,197 @@ router.put('/api/cluster', async (ctx) => {
     }
 });
 
+router.get('/api/agents', async (ctx) => {
+    ctx.body = await acpManager.listState();
+});
+
+router.get('/api/agents/config', async (ctx) => {
+    ctx.body = {
+        configs: await acpManager.listAgentConfigs()
+    };
+});
+
+router.put('/api/agents/config/:agentId', async (ctx) => {
+    const { agentId } = ctx.params;
+    const { env, clearEnvKeys } = ctx.request.body || {};
+    try {
+        const configState = await acpManager.updateAgentConfig(agentId, {
+            env: typeof env === 'object' && env ? env : {},
+            clearEnvKeys: Array.isArray(clearEnvKeys) ? clearEnvKeys : []
+        });
+        ctx.body = {
+            config: configState,
+            definitions: await acpManager.listDefinitions()
+        };
+    } catch (error) {
+        ctx.status = 400;
+        ctx.body = {
+            error: error?.message || 'Failed to save agent config'
+        };
+    }
+});
+
+router.delete('/api/agents/config/:agentId', async (ctx) => {
+    const { agentId } = ctx.params;
+    try {
+        const configState = await acpManager.clearAgentConfig(agentId);
+        ctx.body = {
+            config: configState,
+            definitions: await acpManager.listDefinitions()
+        };
+    } catch (error) {
+        ctx.status = 400;
+        ctx.body = {
+            error: error?.message || 'Failed to clear agent config'
+        };
+    }
+});
+
+router.post('/api/agents/tabs', async (ctx) => {
+    const { agentId, cwd, terminalSessionId, modeId } = ctx.request.body || {};
+    if (!agentId || typeof agentId !== 'string') {
+        ctx.status = 400;
+        ctx.body = { error: 'agentId is required' };
+        return;
+    }
+    if (!cwd || typeof cwd !== 'string') {
+        ctx.status = 400;
+        ctx.body = { error: 'cwd is required' };
+        return;
+    }
+
+    try {
+        ctx.status = 201;
+        ctx.body = await acpManager.createTab({
+            agentId,
+            cwd,
+            terminalSessionId: typeof terminalSessionId === 'string'
+                ? terminalSessionId
+                : '',
+            modeId: typeof modeId === 'string' ? modeId : ''
+        });
+    } catch (error) {
+        ctx.status = 500;
+        ctx.body = { error: error?.message || 'Failed to create agent tab' };
+    }
+});
+
+router.post('/api/agents/tabs/:tabId/prompt', async (ctx) => {
+    const { tabId } = ctx.params;
+    let text = '';
+    let attachments = [];
+
+    if (ctx.is('multipart')) {
+        try {
+            const { fields, files } = await parseMultipartForm(ctx.req);
+            text = firstFormFieldValue(fields?.text);
+            attachments = normalizePromptAttachments(
+                files?.[AGENT_ATTACHMENT_FIELD]
+            );
+        } catch (error) {
+            ctx.status = 400;
+            ctx.body = {
+                error: error?.message || 'Failed to parse prompt attachments'
+            };
+            return;
+        }
+    } else {
+        const body = ctx.request.body || {};
+        text = typeof body.text === 'string' ? body.text : '';
+    }
+
+    if (!text.trim() && attachments.length === 0) {
+        ctx.status = 400;
+        ctx.body = { error: 'text or attachments are required' };
+        return;
+    }
+    try {
+        await acpManager.sendPrompt(tabId, text, attachments);
+        ctx.status = 202;
+        ctx.body = { ok: true };
+    } catch (error) {
+        ctx.status = 500;
+        ctx.body = { error: error?.message || 'Failed to send prompt' };
+    }
+});
+
+router.post('/api/agents/tabs/:tabId/cancel', async (ctx) => {
+    const { tabId } = ctx.params;
+    try {
+        await acpManager.cancel(tabId);
+        ctx.status = 202;
+        ctx.body = { ok: true };
+    } catch (error) {
+        ctx.status = 500;
+        ctx.body = { error: error?.message || 'Failed to cancel prompt' };
+    }
+});
+
+router.post(
+    '/api/agents/tabs/:tabId/permissions/:permissionId',
+    async (ctx) => {
+        const { tabId, permissionId } = ctx.params;
+        const { optionId } = ctx.request.body || {};
+        try {
+            await acpManager.resolvePermission(
+                tabId,
+                permissionId,
+                typeof optionId === 'string' ? optionId : ''
+            );
+            ctx.status = 200;
+            ctx.body = { ok: true };
+        } catch (error) {
+            ctx.status = 500;
+            ctx.body = {
+                error: error?.message || 'Failed to resolve permission'
+            };
+        }
+    }
+);
+
+router.post('/api/agents/tabs/:tabId/mode', async (ctx) => {
+    const { tabId } = ctx.params;
+    const { modeId } = ctx.request.body || {};
+    if (!modeId || typeof modeId !== 'string') {
+        ctx.status = 400;
+        ctx.body = { error: 'modeId is required' };
+        return;
+    }
+    try {
+        ctx.body = await acpManager.setMode(tabId, modeId);
+    } catch (error) {
+        ctx.status = 500;
+        ctx.body = { error: error?.message || 'Failed to switch mode' };
+    }
+});
+
+router.post('/api/agents/tabs/:tabId/config', async (ctx) => {
+    const { tabId } = ctx.params;
+    const { configId, valueId } = ctx.request.body || {};
+    if (!configId || typeof configId !== 'string') {
+        ctx.status = 400;
+        ctx.body = { error: 'configId is required' };
+        return;
+    }
+    if (!valueId || typeof valueId !== 'string') {
+        ctx.status = 400;
+        ctx.body = { error: 'valueId is required' };
+        return;
+    }
+    try {
+        ctx.body = await acpManager.setConfigOption(tabId, configId, valueId);
+    } catch (error) {
+        ctx.status = 500;
+        ctx.body = { error: error?.message || 'Failed to update agent setting' };
+    }
+});
+
+router.delete('/api/agents/tabs/:tabId', async (ctx) => {
+    const { tabId } = ctx.params;
+    await acpManager.closeTab(tabId);
+    ctx.status = 204;
+});
+
 // Middleware
 app.use(router.routes());
 app.use(router.allowedMethods());
@@ -288,7 +545,21 @@ httpServer.on('upgrade', (request, socket, head) => {
     const url = new URL(request.url, `http://${request.headers.host}`);
     const pathname = url.pathname;
 
-    if (pathname.startsWith('/ws/')) {
+    if (pathname.startsWith('/ws/agents/')) {
+        const match = pathname.match(/^\/ws\/agents\/([a-zA-Z0-9-]+)$/);
+        if (!match) {
+            socket.destroy();
+            return;
+        }
+
+        const tabId = match[1];
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            wss.emit('connection', ws, {
+                kind: 'agent',
+                tabId
+            });
+        });
+    } else if (pathname.startsWith('/ws/')) {
         const match = pathname.match(/^\/ws\/([a-zA-Z0-9-]+)$/);
         if (!match) {
             socket.destroy();
@@ -305,20 +576,36 @@ httpServer.on('upgrade', (request, socket, head) => {
                 return;
             }
             const ua = request.headers['user-agent'] || 'Unknown';
-            wss.emit('connection', ws, session, ua);
+            wss.emit('connection', ws, {
+                kind: 'terminal',
+                session,
+                ua
+            });
         });
     } else {
         socket.destroy();
     }
 });
 
-wss.on('connection', (socket, session, ua) => {
+wss.on('connection', (socket, target) => {
     socket.isAlive = true;
     socket.on('pong', () => {
         socket.isAlive = true;
     });
-    debugLog(`[Server] WebSocket connected to session ${session.id} [${ua}]`);
-    session.attach(socket);
+    if (target.kind === 'terminal') {
+        debugLog(
+            `[Server] WebSocket connected to session `
+            + `${target.session.id} [${target.ua}]`
+        );
+        target.session.attach(socket);
+        return;
+    }
+    if (target.kind === 'agent') {
+        debugLog(
+            `[Server] WebSocket connected to agent tab ${target.tabId}`
+        );
+        acpManager.attachSocket(target.tabId, socket);
+    }
 });
 
 const heartbeatInterval = setInterval(() => {
@@ -383,6 +670,7 @@ function shutdown(signal) {
     }
     wss.close();
     terminalManager.dispose();
+    void acpManager.dispose();
 
     const forceExitTimer = setTimeout(() => {
         console.warn('Forced shutdown after timeout.');