@benzsiangco/jarvis 1.0.0 → 1.1.0

package/src/web/server.ts

@@ -0,0 +1,674 @@
+import { Hono } from 'hono';
+import { streamText } from 'hono/streaming';
+import { cors } from 'hono/cors';
+import { serveStatic } from 'hono/bun';
+import { createBunWebSocket } from 'hono/bun';
+import * as pty from 'node-pty';
+import { readdirSync, statSync, readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { loadConfig, saveGlobalConfig } from '../config/index.js';
+import { initializeProviders, getAvailableModels, getProvidersWithStatus, fetchLocalModels } from '../providers/index.js';
+import { initializeAgents, getAgent, getPrimaryAgents } from '../agents/index.js';
+import { initializeTools } from '../tools/index.js';
+import { createSession, getSession, listSessions, getTodos, addMessage, deleteSession } from '../sessions/index.js';
+import { executeAgent } from '../core/executor.js';
+import { getSkillsPath } from '../utils/skills.js';
+import { 
+  getActiveAccount, 
+  getAccountStats, 
+  startAntigravityLogin, 
+  prepareAntigravityLogin,
+  listAccountsWithStatus, 
+  removeAccount 
+} from '../providers/antigravity.js';
+import { pickDirectory } from '../utils/native-picker.js';
+
+const { upgradeWebSocket, websocket } = createBunWebSocket();
+const app = new Hono();
+
+app.onError((err, c) => {
+  console.error('[SERVER ERROR]', err);
+  return c.text('Internal Server Error: ' + err.message, 500);
+});
+
+app.use('*', cors());
+
+let config = loadConfig();
+let globalWorkdir = process.cwd();
+
+// Container mode detection and initialization
+const isContainerMode = () => {
+  return process.env.JARVIS_MODE === 'container' ||
+         process.env.JARVIS_MODE === 'web' ||
+         process.env.DOCKER === 'true' ||
+         existsSync('/.dockerenv');
+};
+
+const initializeDefaultWorkspace = () => {
+  if (!isContainerMode()) {
+    console.log('[Server] Running in desktop mode');
+    return;
+  }
+  
+  console.log('[Server] Container mode detected - initializing default workspace');
+  
+  const workspacePath = process.env.JARVIS_WORKSPACE || '/workspace';
+  const cfg = loadConfig();
+  
+  // Check if default workspace already exists
+  const hasDefault = cfg.workspaces?.some((w: any) => w.id === 'default');
+  
+  if (!hasDefault) {
+    // Create workspace directory if it doesn't exist
+    if (!existsSync(workspacePath)) {
+      mkdirSync(workspacePath, { recursive: true });
+      console.log('[Server] Created workspace directory:', workspacePath);
+    }
+    
+    // Create default workspace
+    const defaultWorkspace = {
+      id: 'default',
+      name: 'Container Workspace',
+      path: workspacePath,
+      icon: 'C'
+    };
+    
+    cfg.workspaces = [...(cfg.workspaces || []), defaultWorkspace];
+    saveGlobalConfig(cfg);
+    globalWorkdir = workspacePath;
+    
+    console.log('[Server] Default workspace initialized:', workspacePath);
+  } else {
+    console.log('[Server] Default workspace already exists');
+    const defaultWs = cfg.workspaces?.find((w: any) => w.id === 'default');
+    if (defaultWs) {
+      globalWorkdir = defaultWs.path;
+    }
+  }
+};
+
+// Initialize container mode if applicable
+initializeDefaultWorkspace();
+
+await initializeProviders(config);
+initializeAgents(config.agent);
+initializeTools();
+
+// --- Terminal PTY Service ---
+app.get('/terminal', upgradeWebSocket((c) => {
+  return {
+    onOpen(_event, ws) {
+      const shell = process.platform === 'win32' ? 'powershell.exe' : 'bash';
+      const ptyProcess = pty.spawn(shell, [], {
+        name: 'xterm-color',
+        cols: 80,
+        rows: 24,
+        cwd: globalWorkdir,
+        env: process.env as any,
+      });
+      ptyProcess.onData((data) => ws.send(data));
+      (ws as any).pty = ptyProcess;
+    },
+    onMessage(event, ws) {
+      const ptyProcess = (ws as any).pty;
+      if (!ptyProcess) return;
+      const data = event.data.toString();
+      
+      if (data.startsWith('{"resize":')) {
+        try {
+          const { resize } = JSON.parse(data);
+          ptyProcess.resize(resize.cols, resize.rows);
+        } catch (e) {}
+      } else if (data === '{"action":"kill"}') {
+        // Send SIGINT to the process group if possible, or just kill the process
+        if (process.platform !== 'win32') {
+          ptyProcess.kill('SIGINT');
+        } else {
+          ptyProcess.kill();
+        }
+        ws.send('\r\n\x1b[31;1m[SYSTEM] Process terminated by user.\x1b[0m\r\n');
+      } else {
+        // Ensure we send a string to ptyProcess.write
+        let input: string;
+        if (typeof event.data === 'string') {
+          input = event.data;
+        } else if (event.data instanceof ArrayBuffer) {
+          input = new TextDecoder().decode(event.data);
+        } else {
+          input = event.data.toString();
+        }
+        ptyProcess.write(input);
+      }
+    },
+    onClose(_event, ws) {
+      const ptyProcess = (ws as any).pty;
+      if (ptyProcess) ptyProcess.kill();
+    }
+  };
+}));
+
+// --- Enhanced Management APIs ---
+// --- Workspace Management ---
+app.get('/api/workspaces', (c) => {
+  const cfg = loadConfig();
+  return c.json({ workspaces: cfg.workspaces || [] });
+});
+
+app.post('/api/workspaces', async (c) => {
+  try {
+    console.log('[API] Starting workspace creation...');
+    
+    // Get folder info from request body (sent by frontend HTML5 picker)
+    const body = await c.req.json();
+    const { name, path } = body;
+    
+    if (!name || !path) {
+      console.log('[API] Missing name or path');
+      return c.json({ error: 'Missing name or path' }, 400);
+    }
+    
+    console.log('[API] Workspace info received:', { name, path });
+    
+    const cfg = loadConfig();
+    
+    // Check if workspace already exists
+    const existing = (cfg.workspaces || []).find((w: any) => w.path === path);
+    if (existing) {
+      console.log('[API] Workspace already exists');
+      return c.json({ error: 'Workspace already exists', workspace: existing }, 409);
+    }
+    
+    // Create new workspace
+    const newWs = {
+      id: `ws_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+      name,
+      path,
+      icon: (name[0] || 'W').toUpperCase()
+    };
+    
+    console.log('[API] Creating workspace:', newWs);
+    
+    // Save to config
+    const workspaces = [...(cfg.workspaces || []), newWs];
+    saveGlobalConfig({ ...cfg, workspaces });
+    
+    globalWorkdir = path;
+    
+    console.log('[API] Workspace created successfully');
+    return c.json(newWs);
+    
+  } catch (e) {
+    console.error('[API] Workspace creation failed:', e);
+    return c.json({ error: (e as Error).message }, 500);
+  }
+});
+
+app.delete('/api/workspaces/:id', (c) => {
+  const id = c.req.param('id');
+  console.log('[API] Deleting workspace:', id);
+  
+  const cfg = loadConfig();
+  const before = cfg.workspaces?.length || 0;
+  const workspaces = (cfg.workspaces || []).filter((w: any) => w.id !== id);
+  const after = workspaces.length;
+  
+  if (before === after) {
+    console.log('[API] Workspace not found:', id);
+    return c.json({ error: 'Workspace not found' }, 404);
+  }
+  
+  saveGlobalConfig({ ...cfg, workspaces });
+  console.log('[API] Workspace deleted successfully');
+  
+  return c.json({ success: true });
+});
+
+// Clean all workspaces
+app.delete('/api/workspaces', (c) => {
+  console.log('[API] Cleaning all workspaces');
+  
+  const cfg = loadConfig();
+  saveGlobalConfig({ ...cfg, workspaces: [] });
+  console.log('[API] All workspaces cleaned successfully');
+  
+  return c.json({ success: true });
+});
+
+// --- Unified Config CRUD ---
+app.post('/api/config/full', async (c) => {
+  const payload = await c.req.json();
+  const currentConfig = loadConfig();
+  
+  const updatedConfig = {
+    ...currentConfig,
+    instructions: payload.instructions ?? currentConfig.instructions,
+    persona: payload.persona ?? currentConfig.persona,
+    permission: payload.permission ?? currentConfig.permission,
+    restrictedPaths: payload.restrictedPaths ?? currentConfig.restrictedPaths,
+  };
+  
+  saveGlobalConfig(updatedConfig);
+  return c.json({ success: true });
+});
+
+app.get('/api/fs/list', (c) => {
+  const path = c.req.query('path') || globalWorkdir;
+  try {
+    const entries = readdirSync(path, { withFileTypes: true });
+    const items = entries.map(e => ({
+      name: e.name,
+      path: join(path, e.name),
+      isDirectory: e.isDirectory(),
+      size: e.isFile() ? statSync(join(path, e.name)).size : 0
+    })).sort((a, b) => (a.isDirectory === b.isDirectory ? a.name.localeCompare(b.name) : a.isDirectory ? -1 : 1));
+    return c.json({ path, items });
+  } catch (e) {
+    return c.json({ error: (e as Error).message }, 400);
+  }
+});
+
+app.get('/api/fs/roots', (c) => {
+  if (process.platform === 'win32') {
+    const drives = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('').map(d => `${d}:\\`).filter(d => existsSync(d));
+    return c.json({ roots: drives });
+  }
+  return c.json({ roots: ['/'] });
+});
+
+app.get('/api/workdir/pick', async (c) => {
+  console.log('[SERVER] Triggering native directory picker...');
+  const { path: pickedPath, error } = await pickDirectory();
+  if (pickedPath) {
+    console.log(`[SERVER] Directory picked: ${pickedPath}`);
+    globalWorkdir = pickedPath;
+    return c.json({ path: pickedPath });
+  }
+  console.log('[SERVER] Directory selection cancelled or failed:', error);
+  return c.json({ error: error || 'Selection cancelled' }, 400);
+});
+
+app.post('/api/workdir', async (c) => {
+  const { path } = await c.req.json();
+  if (path && existsSync(path)) {
+    globalWorkdir = path;
+    return c.json({ success: true, path: globalWorkdir });
+  }
+  return c.json({ error: 'Invalid path' }, 400);
+});
+
+app.get('/api/skills', (c) => {
+  const path = getSkillsPath();
+  const content = existsSync(path) ? readFileSync(path, 'utf-8') : '# Skills\n';
+  return c.json({ content });
+});
+
+app.post('/api/skills', async (c) => {
+  const { content } = await c.req.json();
+  writeFileSync(getSkillsPath(), content, 'utf-8');
+  return c.json({ success: true });
+});
+
+// Brain endpoints
+app.get('/api/brain', async (c) => {
+  try {
+    const { loadBrain, hasBrain } = await import('../brain/loader.js');
+    
+    if (!hasBrain()) {
+      return c.json({ content: '', exists: false });
+    }
+    
+    const content = loadBrain();
+    return c.json({ content, exists: true });
+  } catch (e) {
+    console.error('[API] Brain load error:', e);
+    return c.json({ content: '', exists: false });
+  }
+});
+
+app.post('/api/brain', async (c) => {
+  try {
+    const { content } = await c.req.json();
+    const { saveBrain } = await import('../brain/loader.js');
+    
+    saveBrain(content);
+    console.log('[API] Brain updated');
+    
+    return c.json({ success: true });
+  } catch (e) {
+    console.error('[API] Brain save error:', e);
+    return c.json({ error: (e as Error).message }, 500);
+  }
+});
+
+app.get('/api/config', (c) => c.json({ ...loadConfig(), workdir: globalWorkdir }));
+
+app.get('/api/models', async (c) => {
+  try {
+    const config = loadConfig();
+    const staticModels = getAvailableModels(config);
+    
+    // For now, skip local models fetching to prevent hanging
+    // TODO: Fix local models fetching properly
+    const allModels = staticModels;
+    
+    return c.json(allModels);
+  } catch (e) {
+    console.error('[Models API] Error:', (e as Error).message);
+    // Return minimal models on error
+    return c.json([
+      { id: 'gpt-4o', name: 'GPT-4o', provider: 'openai', isAvailable: false },
+      { id: 'claude-3-5-sonnet-20241022', name: 'Claude 3.5 Sonnet', provider: 'anthropic', isAvailable: false }
+    ]);
+  }
+});
+
+app.get('/api/sessions', (c) => {
+  const allSessions = listSessions();
+  const workdir = c.req.query('workdir');
+  
+  let filtered = allSessions;
+  if (workdir) {
+    filtered = allSessions.filter(s => s.workdir === workdir);
+  }
+
+  // Return flat list, the frontend will handle tree construction for simplicity and flexibility
+  return c.json(filtered);
+});
+
+app.post('/api/sessions', async (c) => {
+  const { agentId, workdir } = await c.req.json();
+  const session = createSession(agentId || 'build', undefined, undefined, workdir || globalWorkdir);
+  
+  // Store model metadata for session stats
+  const currentModel = config.model || 'gemini-2.0-flash-exp';
+  const getProviderFromModel = (modelId: string): string => {
+    if (modelId.startsWith('gemini')) return 'google';
+    if (modelId.startsWith('claude')) return 'anthropic';
+    if (modelId.startsWith('gpt') || modelId.startsWith('o1') || modelId.startsWith('o3')) return 'openai';
+    return 'unknown';
+  };
+  
+  session.metadata = {
+    ...session.metadata,
+    modelId: currentModel,
+    providerId: getProviderFromModel(currentModel),
+    persona: config.persona,
+  };
+  
+  return c.json(session);
+});
+
+app.get('/api/sessions/:id', (c) => {
+  const session = getSession(c.req.param('id'));
+  if (!session) return c.json({ error: 'Session not found' }, 404);
+  return c.json(session);
+});
+
+app.delete('/api/sessions/:id', (c) => {
+  const id = c.req.param('id');
+  console.log('[API] Deleting session:', id);
+  
+  try {
+    const session = getSession(id);
+    if (!session) {
+      console.log('[API] Session not found:', id);
+      return c.json({ error: 'Session not found' }, 404);
+    }
+    
+    // Delete the session
+    deleteSession(id);
+    
+    console.log('[API] Session deleted successfully');
+    return c.json({ success: true });
+  } catch (e) {
+    console.error('[API] Failed to delete session:', e);
+    return c.json({ error: (e as Error).message }, 500);
+  }
+});
+
+
+app.post('/api/config/prompt', async (c) => {
+  const { prompt } = await c.req.json();
+  const newConfig = { ...loadConfig(), instructions: prompt };
+  saveGlobalConfig(newConfig);
+  return c.json({ success: true });
+});
+
+app.post('/api/config/safety', async (c) => {
+  const { permission, restrictedPaths } = await c.req.json();
+  const newConfig = { ...loadConfig(), permission, restrictedPaths };
+  saveGlobalConfig(newConfig);
+  return c.json({ success: true });
+});
+
+app.get('/api/auth/status', (c) => c.json({ 
+  providers: getProvidersWithStatus(),
+  activeAccount: getActiveAccount(),
+  stats: getAccountStats(),
+  accounts: listAccountsWithStatus()
+}));
+
+app.post('/api/auth/antigravity/login', async (c) => {
+  try {
+    // Generate URL and start listener in background
+    const url = await prepareAntigravityLogin();
+    return c.json({ success: true, url, message: 'OAuth flow initiated.' });
+  } catch (e) {
+    return c.json({ success: false, error: (e as Error).message }, 500);
+  }
+});
+
+app.post('/api/auth/key', async (c) => {
+  const { providerId, apiKey } = await c.req.json();
+  const cfg = loadConfig();
+  
+  if (!cfg.provider) cfg.provider = {};
+  if (!cfg.provider[providerId]) cfg.provider[providerId] = { id: providerId, models: {} };
+  
+  cfg.provider[providerId]!.apiKey = apiKey;
+  saveGlobalConfig(cfg);
+  
+  // Re-initialize providers
+  await initializeProviders(cfg);
+  
+  return c.json({ success: true });
+});
+
+app.delete('/api/auth/account/:id', async (c) => {
+  const id = c.req.param('id');
+  const removed = removeAccount(id);
+  return c.json({ success: removed });
+});
+
+// OAuth configuration endpoints
+app.get('/api/oauth/config', (c) => {
+  const cfg = loadConfig();
+  const defaultUrl = 'http://localhost:51121/oauth-callback';
+  
+  return c.json({
+    callbackUrl: cfg.oauth?.callbackUrl || null,
+    callbackHost: cfg.oauth?.callbackHost || '0.0.0.0',
+    callbackPort: cfg.oauth?.callbackPort || 51121,
+    defaultUrl,
+    currentUrl: cfg.oauth?.callbackUrl || defaultUrl,
+  });
+});
+
+app.post('/api/oauth/config', async (c) => {
+  const { callbackUrl, callbackHost, callbackPort } = await c.req.json();
+  
+  // Validate URL format if provided
+  if (callbackUrl && callbackUrl.trim()) {
+    try {
+      new URL(callbackUrl);
+    } catch (e) {
+      return c.json({ error: 'Invalid callback URL format' }, 400);
+    }
+  }
+  
+  const cfg = loadConfig();
+  const updatedConfig = {
+    ...cfg,
+    oauth: {
+      callbackUrl: callbackUrl?.trim() || undefined,
+      callbackHost: callbackHost || '0.0.0.0',
+      callbackPort: callbackPort || 51121,
+    }
+  };
+  
+  saveGlobalConfig(updatedConfig);
+  console.log('[API] OAuth config updated:', updatedConfig.oauth);
+  
+  return c.json({ success: true, config: updatedConfig.oauth });
+});
+
+app.delete('/api/oauth/config', (c) => {
+  const cfg = loadConfig();
+  const updatedConfig = { ...cfg };
+  delete updatedConfig.oauth;
+  
+  saveGlobalConfig(updatedConfig);
+  console.log('[API] OAuth config reset to defaults');
+  
+  return c.json({ success: true });
+});
+
+const abortControllers = new Map<string, AbortController>();
+
+// --- Core Chat API ---
+app.post('/api/chat/cancel', async (c) => {
+  const { sessionId } = await c.req.json();
+  const controller = abortControllers.get(sessionId);
+  if (controller) {
+    controller.abort();
+    abortControllers.delete(sessionId);
+    return c.json({ success: true });
+  }
+  return c.json({ error: 'No active process found for this session' }, 404);
+});
+
+app.post('/api/chat', async (c) => {
+  const { sessionId, message, agentId, modelId, variant, attachments } = await c.req.json();
+  let session = getSession(sessionId);
+  if (!session) session = createSession(agentId || 'build', undefined, undefined, globalWorkdir);
+  const agent = getAgent(agentId || session.agentId || 'build');
+
+  // Save user message to session
+  addMessage(session.id, {
+    role: 'user',
+    content: message,
+    attachments: attachments || []
+  });
+
+  // Format message with attachments for multimodal support
+  let messageContent: any = message;
+  
+  if (attachments && attachments.length > 0) {
+    // Build content array with text and images
+    const contentParts: any[] = [{ type: 'text', text: message }];
+    
+    for (const attachment of attachments) {
+      if (attachment.type?.startsWith('image/') && attachment.content) {
+        // Extract base64 data from data URL
+        const base64Match = attachment.content.match(/^data:image\/[^;]+;base64,(.+)$/);
+        if (base64Match) {
+          contentParts.push({
+            type: 'image',
+            image: attachment.content // Use the full data URL
+          });
+        }
+      }
+    }
+    
+    // If we have images, use content array format
+    if (contentParts.length > 1) {
+      messageContent = contentParts;
+    }
+  }
+
+  // Cancel any existing request for this session
+  if (abortControllers.has(sessionId)) {
+    abortControllers.get(sessionId)?.abort();
+  }
+
+  const controller = new AbortController();
+  abortControllers.set(sessionId, controller);
+
+  // Accumulate assistant response
+  let accumulatedContent = '';
+  let accumulatedThinking = '';
+  let accumulatedToolCalls: any[] = [];
+
+  return streamText(c, async (stream) => {
+    try {
+      await executeAgent(messageContent, {
+        session,
+        agent: { 
+          ...agent!, 
+          model: modelId || agent!.model || loadConfig().model,
+          options: { ...agent!.options, variant }
+        },
+        signal: controller.signal,
+        onText: (text) => {
+          accumulatedContent += text;
+          stream.write(text);
+        },
+        onThinking: (thought) => {
+          accumulatedThinking += thought;
+          stream.write(`<<<THOUGHT>>>${thought}<<<END_THOUGHT>>>`);
+        },
+        onToolStart: (name, args) => stream.write(`<<<TOOL_START:{"name":"${name}","args":${JSON.stringify(args)}}>>>`),
+        onToolEnd: (name, result) => {
+          // Track tool calls
+          const existingCall = accumulatedToolCalls.find(t => t.name === name && !t.result);
+          if (existingCall) {
+            existingCall.result = result;
+          } else {
+            accumulatedToolCalls.push({ name, args: {}, result });
+          }
+          stream.write(`<<<TOOL_END:{"name":"${name}","result":${JSON.stringify(result)}}>>>`);
+        },
+      });
+
+      // Save assistant message to session after streaming completes
+      addMessage(session!.id, {
+        role: 'assistant',
+        content: accumulatedContent,
+        thinking: accumulatedThinking || undefined,
+        toolCalls: accumulatedToolCalls.length > 0 ? accumulatedToolCalls : undefined
+      });
+    } catch (error) {
+      if ((error as any).name === 'AbortError') {
+        stream.write(`\n[SYSTEM] Execution cancelled by user.`);
+      } else {
+        stream.write(`\nError: ${(error as Error).message}`);
+      }
+    } finally {
+      abortControllers.delete(sessionId);
+    }
+  });
+});
+
+app.get('/', async (c) => {
+  try {
+    const indexPath = join(import.meta.dir, 'ui', 'index.html');
+    if (existsSync(indexPath)) {
+      const content = readFileSync(indexPath, 'utf-8');
+      return c.html(content);
+    }
+    return c.text('UI index.html not found at ' + indexPath, 404);
+  } catch (e) {
+    console.error('[SERVER] Error serving index.html:', (e as Error).message);
+    return c.text('Internal Server Error: ' + (e as Error).message, 500);
+  }
+});
+
+// Static Assets
+const webRoot = join(import.meta.dir, 'ui', 'dist');
+app.use('/*', serveStatic({ 
+  root: webRoot,
+  rewriteRequestPath: (path) => (path.includes('?') ? path.split('?')[0] : path) || '/'
+}));
+
+export default { port: 1138, fetch: app.fetch, websocket };
+console.log('J.A.R.V.I.S. Multi-Channel Server active on http://0.0.0.0:1138');

package/src/web/ui/dist/main.css

@@ -0,0 +1 @@
+.xterm{cursor:text;position:relative;user-select:none;-ms-user-select:none;-webkit-user-select:none}.xterm.focus,.xterm:focus{outline:none}.xterm .xterm-helpers{position:absolute;z-index:5;top:0}.xterm .xterm-helper-textarea{position:absolute;opacity:0;z-index:-5;white-space:nowrap;overflow:hidden;resize:none;border:0;width:0;height:0;margin:0;padding:0;top:0;left:-9999em}.xterm .composition-view{color:#fff;display:none;position:absolute;white-space:nowrap;z-index:1;background:#000}.xterm .composition-view.active{display:block}.xterm .xterm-viewport{overflow-y:scroll;cursor:default;position:absolute;background-color:#000;inset:0}.xterm .xterm-screen{position:relative}.xterm .xterm-screen canvas{position:absolute;top:0;left:0}.xterm .xterm-scroll-area{visibility:hidden}.xterm-char-measure-element{display:inline-block;visibility:hidden;position:absolute;line-height:normal;top:0;left:-9999em}.xterm.enable-mouse-events{cursor:default}.xterm.xterm-cursor-pointer,.xterm .xterm-cursor-pointer{cursor:pointer}.xterm.column-select.focus{cursor:crosshair}.xterm .xterm-accessibility,.xterm .xterm-message{position:absolute;z-index:10;color:#0000;pointer-events:none;inset:0}.xterm .live-region{position:absolute;overflow:hidden;width:1px;height:1px;left:-9999px}.xterm-dim{opacity:1!important}.xterm-underline-1{text-decoration:underline}.xterm-underline-2{text-decoration:double underline}.xterm-underline-3{text-decoration:wavy underline}.xterm-underline-4{text-decoration:dotted underline}.xterm-underline-5{text-decoration:dashed underline}.xterm-overline{text-decoration:overline}.xterm-overline.xterm-underline-1{text-decoration:overline underline}.xterm-overline.xterm-underline-2{text-decoration:overline double underline}.xterm-overline.xterm-underline-3{text-decoration:overline wavy underline}.xterm-overline.xterm-underline-4{text-decoration:overline dotted underline}.xterm-overline.xterm-underline-5{text-decoration:overline dashed underline}.xterm-strikethrough{text-decoration:line-through}.xterm-screen .xterm-decoration-container .xterm-decoration{z-index:6;position:absolute}.xterm-screen .xterm-decoration-container .xterm-decoration.xterm-decoration-top-layer{z-index:7}.xterm-decoration-overview-ruler{z-index:8;position:absolute;pointer-events:none;top:0;right:0}.xterm-decoration-top{z-index:2;position:relative}