@bytespell/shella 0.2.4 → 0.2.6

package/bundled-plugins/agent/src/utils.test.ts

@@ -0,0 +1,393 @@
+import { describe, it, expect } from 'vitest'
+import {
+  splitAssistantContent,
+  getTextFromBlocks,
+  buildToolCallMap,
+  getCompletedToolCallIds,
+  buildRenderItems,
+} from './utils'
+import type { ContentBlock, AgentMessage } from './types'
+
+describe('splitAssistantContent', () => {
+  it('returns empty array for empty content', () => {
+    const result = splitAssistantContent([], false)
+    expect(result).toEqual([])
+  })
+
+  it('groups consecutive text blocks', () => {
+    const content: ContentBlock[] = [
+      { type: 'text', text: 'Hello' },
+      { type: 'text', text: 'World' },
+    ]
+    const result = splitAssistantContent(content, false)
+    expect(result).toHaveLength(1)
+    expect(result[0]).toEqual({
+      type: 'text-chunk',
+      blocks: content,
+      isStreaming: false,
+    })
+  })
+
+  it('separates tool calls from text', () => {
+    const content: ContentBlock[] = [
+      { type: 'text', text: 'Let me run a command' },
+      { type: 'toolCall', id: 'call_1', name: 'Bash', arguments: { command: 'ls' } },
+    ]
+    const result = splitAssistantContent(content, false)
+    expect(result).toHaveLength(2)
+    expect(result[0]).toEqual({
+      type: 'text-chunk',
+      blocks: [{ type: 'text', text: 'Let me run a command' }],
+      isStreaming: false,
+    })
+    expect(result[1]).toEqual({
+      type: 'tool-call',
+      id: 'call_1',
+      name: 'Bash',
+      args: { command: 'ls' },
+    })
+  })
+
+  it('handles text before and after tool call', () => {
+    const content: ContentBlock[] = [
+      { type: 'text', text: 'Before' },
+      { type: 'toolCall', id: 'call_1', name: 'Bash', arguments: { command: 'ls' } },
+      { type: 'text', text: 'After' },
+    ]
+    const result = splitAssistantContent(content, false)
+    expect(result).toHaveLength(3)
+    expect(result[0]?.type).toBe('text-chunk')
+    expect(result[1]?.type).toBe('tool-call')
+    expect(result[2]?.type).toBe('text-chunk')
+  })
+
+  it('handles multiple tool calls', () => {
+    const content: ContentBlock[] = [
+      { type: 'toolCall', id: 'call_1', name: 'Read', arguments: { path: 'a.txt' } },
+      { type: 'toolCall', id: 'call_2', name: 'Read', arguments: { path: 'b.txt' } },
+    ]
+    const result = splitAssistantContent(content, false)
+    expect(result).toHaveLength(2)
+    expect(result[0]?.type).toBe('tool-call')
+    expect(result[1]?.type).toBe('tool-call')
+  })
+
+  it('marks last text chunk as streaming when isStreaming=true', () => {
+    const content: ContentBlock[] = [
+      { type: 'text', text: 'Before tool' },
+      { type: 'toolCall', id: 'call_1', name: 'Bash', arguments: { command: 'ls' } },
+      { type: 'text', text: 'After tool, still typing...' },
+    ]
+    const result = splitAssistantContent(content, true)
+    expect(result).toHaveLength(3)
+    // First text chunk should NOT be streaming
+    expect(result[0]).toEqual({
+      type: 'text-chunk',
+      blocks: [{ type: 'text', text: 'Before tool' }],
+      isStreaming: false,
+    })
+    // Last text chunk SHOULD be streaming
+    expect(result[2]).toEqual({
+      type: 'text-chunk',
+      blocks: [{ type: 'text', text: 'After tool, still typing...' }],
+      isStreaming: true,
+    })
+  })
+
+  it('includes thinking blocks in text chunks', () => {
+    const content: ContentBlock[] = [
+      { type: 'thinking', thinking: 'Let me think about this...' },
+      { type: 'text', text: 'Here is my answer' },
+    ]
+    const result = splitAssistantContent(content, false)
+    expect(result).toHaveLength(1)
+    expect(result[0]).toEqual({
+      type: 'text-chunk',
+      blocks: content,
+      isStreaming: false,
+    })
+  })
+})
+
+describe('getTextFromBlocks', () => {
+  it('returns empty string for empty array', () => {
+    expect(getTextFromBlocks([])).toBe('')
+  })
+
+  it('returns first text block content', () => {
+    const blocks: ContentBlock[] = [
+      { type: 'text', text: 'Hello world' },
+    ]
+    expect(getTextFromBlocks(blocks)).toBe('Hello world')
+  })
+
+  it('ignores non-text blocks', () => {
+    const blocks: ContentBlock[] = [
+      { type: 'thinking', thinking: 'thinking...' },
+      { type: 'text', text: 'The answer' },
+    ]
+    expect(getTextFromBlocks(blocks)).toBe('The answer')
+  })
+
+  it('returns empty string if no text blocks', () => {
+    const blocks: ContentBlock[] = [
+      { type: 'thinking', thinking: 'thinking...' },
+    ]
+    expect(getTextFromBlocks(blocks)).toBe('')
+  })
+})
+
+describe('buildToolCallMap', () => {
+  it('returns empty map for empty messages', () => {
+    const map = buildToolCallMap([])
+    expect(map.size).toBe(0)
+  })
+
+  it('extracts tool calls from assistant messages', () => {
+    const messages: AgentMessage[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'text', text: 'Let me run this' },
+          { type: 'toolCall', id: 'call_1', name: 'Bash', arguments: { command: 'ls -la' } },
+        ],
+      },
+    ]
+    const map = buildToolCallMap(messages)
+    expect(map.size).toBe(1)
+    expect(map.get('call_1')).toEqual({ name: 'Bash', args: { command: 'ls -la' } })
+  })
+
+  it('ignores user and toolResult messages', () => {
+    const messages: AgentMessage[] = [
+      { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
+      { role: 'toolResult', toolCallId: 'call_1', toolName: 'Bash', content: [{ type: 'text', text: 'output' }] },
+    ]
+    const map = buildToolCallMap(messages)
+    expect(map.size).toBe(0)
+  })
+
+  it('handles multiple tool calls in one message', () => {
+    const messages: AgentMessage[] = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'toolCall', id: 'call_1', name: 'Read', arguments: { path: 'a.txt' } },
+          { type: 'toolCall', id: 'call_2', name: 'Read', arguments: { path: 'b.txt' } },
+        ],
+      },
+    ]
+    const map = buildToolCallMap(messages)
+    expect(map.size).toBe(2)
+    expect(map.get('call_1')).toEqual({ name: 'Read', args: { path: 'a.txt' } })
+    expect(map.get('call_2')).toEqual({ name: 'Read', args: { path: 'b.txt' } })
+  })
+})
+
+describe('getCompletedToolCallIds', () => {
+  it('returns empty set for empty messages', () => {
+    const set = getCompletedToolCallIds([])
+    expect(set.size).toBe(0)
+  })
+
+  it('collects toolCallIds from toolResult messages', () => {
+    const messages: AgentMessage[] = [
+      { role: 'toolResult', toolCallId: 'call_1', toolName: 'Bash', content: [] },
+      { role: 'toolResult', toolCallId: 'call_2', toolName: 'Read', content: [] },
+    ]
+    const set = getCompletedToolCallIds(messages)
+    expect(set.size).toBe(2)
+    expect(set.has('call_1')).toBe(true)
+    expect(set.has('call_2')).toBe(true)
+  })
+
+  it('ignores other message types', () => {
+    const messages: AgentMessage[] = [
+      { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
+      { role: 'assistant', content: [{ type: 'text', text: 'Hi' }] },
+    ]
+    const set = getCompletedToolCallIds(messages)
+    expect(set.size).toBe(0)
+  })
+})
+
+describe('buildRenderItems', () => {
+  it('returns empty array for empty messages', () => {
+    const items = buildRenderItems([], null, new Map(), new Set())
+    expect(items).toEqual([])
+  })
+
+  it('renders user message as user-message item', () => {
+    const messages: AgentMessage[] = [
+      { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
+    ]
+    const items = buildRenderItems(messages, null, new Map(), new Set())
+    expect(items).toHaveLength(1)
+    expect(items[0]?.type).toBe('user-message')
+  })
+
+  it('skips user messages with only whitespace', () => {
+    const messages: AgentMessage[] = [
+      { role: 'user', content: [{ type: 'text', text: '   ' }] },
+    ]
+    const items = buildRenderItems(messages, null, new Map(), new Set())
+    expect(items).toHaveLength(0)
+  })
+
+  it('renders assistant text as text-chunk', () => {
+    const messages: AgentMessage[] = [
+      { role: 'assistant', content: [{ type: 'text', text: 'Hello back' }] },
+    ]
+    const items = buildRenderItems(messages, null, new Map(), new Set())
+    expect(items).toHaveLength(1)
+    expect(items[0]?.type).toBe('text-chunk')
+  })
+
+  it('skips empty assistant text chunks', () => {
+    const messages: AgentMessage[] = [
+      { role: 'assistant', content: [{ type: 'text', text: '' }] },
+    ]
+    const items = buildRenderItems(messages, null, new Map(), new Set())
+    expect(items).toHaveLength(0)
+  })
+
+  it('renders tool result with command for bash tools', () => {
+    const messages: AgentMessage[] = [
+      { role: 'toolResult', toolCallId: 'call_1', toolName: 'Bash', content: [{ type: 'text', text: 'file1.txt\nfile2.txt' }] },
+    ]
+    const toolCallMap = new Map([['call_1', { name: 'Bash', args: { command: 'ls' } }]])
+    const items = buildRenderItems(messages, null, toolCallMap, new Set(['call_1']))
+    expect(items).toHaveLength(1)
+    expect(items[0]).toEqual({
+      type: 'tool-result',
+      toolCallId: 'call_1',
+      toolName: 'Bash',
+      command: 'ls',
+      output: 'file1.txt\nfile2.txt',
+      isError: false,
+    })
+  })
+
+  it('renders tool result without command for non-bash tools', () => {
+    const messages: AgentMessage[] = [
+      { role: 'toolResult', toolCallId: 'call_1', toolName: 'Read', content: [{ type: 'text', text: 'file content' }] },
+    ]
+    const toolCallMap = new Map([['call_1', { name: 'Read', args: { path: 'test.txt' } }]])
+    const items = buildRenderItems(messages, null, toolCallMap, new Set(['call_1']))
+    expect(items).toHaveLength(1)
+    expect(items[0]).toEqual({
+      type: 'tool-result',
+      toolCallId: 'call_1',
+      toolName: 'Read',
+      command: undefined,
+      output: 'file content',
+      isError: false,
+    })
+  })
+
+  it('shows tool-call when result not yet received', () => {
+    const messages: AgentMessage[] = [
+      {
+        role: 'assistant',
+        content: [{ type: 'toolCall', id: 'call_1', name: 'Bash', arguments: { command: 'ls' } }],
+      },
+    ]
+    const items = buildRenderItems(messages, null, new Map(), new Set())
+    expect(items).toHaveLength(1)
+    expect(items[0]?.type).toBe('tool-call')
+  })
+
+  it('hides tool-call when result is received', () => {
+    const messages: AgentMessage[] = [
+      {
+        role: 'assistant',
+        content: [{ type: 'toolCall', id: 'call_1', name: 'Bash', arguments: { command: 'ls' } }],
+      },
+      { role: 'toolResult', toolCallId: 'call_1', toolName: 'Bash', content: [{ type: 'text', text: 'output' }] },
+    ]
+    const toolCallMap = new Map([['call_1', { name: 'Bash', args: { command: 'ls' } }]])
+    const completedIds = new Set(['call_1'])
+    const items = buildRenderItems(messages, null, toolCallMap, completedIds)
+    // Should only have the tool-result, not the tool-call
+    expect(items).toHaveLength(1)
+    expect(items[0]?.type).toBe('tool-result')
+  })
+
+  it('marks streaming message text as streaming', () => {
+    const messages: AgentMessage[] = [
+      { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
+      { role: 'assistant', content: [{ type: 'text', text: 'I am typing...' }] },
+    ]
+    const items = buildRenderItems(messages, 1, new Map(), new Set())
+    expect(items).toHaveLength(2)
+    expect(items[1]).toEqual({
+      type: 'text-chunk',
+      blocks: [{ type: 'text', text: 'I am typing...' }],
+      isStreaming: true,
+    })
+  })
+
+  it('handles error tool results', () => {
+    const messages: AgentMessage[] = [
+      { role: 'toolResult', toolCallId: 'call_1', toolName: 'Bash', content: [{ type: 'text', text: 'command not found' }], isError: true },
+    ]
+    const items = buildRenderItems(messages, null, new Map(), new Set())
+    expect(items).toHaveLength(1)
+    expect(items[0]).toMatchObject({
+      type: 'tool-result',
+      isError: true,
+    })
+  })
+
+  it('extracts diff for Edit tool results', () => {
+    const messages: AgentMessage[] = [
+      {
+        role: 'assistant',
+        content: [{ type: 'toolCall', id: 'call_1', name: 'Edit', arguments: { file_path: 'src/App.tsx', old_string: 'foo', new_string: 'bar' } }],
+      },
+      {
+        role: 'toolResult',
+        toolCallId: 'call_1',
+        toolName: 'Edit',
+        content: [{ type: 'text', text: 'Successfully edited src/App.tsx' }],
+        details: { diff: '--- a/src/App.tsx\n+++ b/src/App.tsx\n@@ -1,1 +1,1 @@\n-foo\n+bar' },
+      },
+    ]
+    const toolCallMap = new Map([['call_1', { name: 'Edit', args: { file_path: 'src/App.tsx' } }]])
+    const completedIds = new Set(['call_1'])
+    const items = buildRenderItems(messages, null, toolCallMap, completedIds)
+
+    expect(items).toHaveLength(1)
+    expect(items[0]?.type).toBe('tool-result')
+    const result = items[0] as { type: 'tool-result'; diff?: string; filePath?: string }
+    expect(result.diff).toBe('--- a/src/App.tsx\n+++ b/src/App.tsx\n@@ -1,1 +1,1 @@\n-foo\n+bar')
+    expect(result.filePath).toBe('src/App.tsx')
+  })
+
+  it('handles full conversation flow', () => {
+    const messages: AgentMessage[] = [
+      { role: 'user', content: [{ type: 'text', text: 'List files' }] },
+      {
+        role: 'assistant',
+        content: [
+          { type: 'text', text: 'Sure, let me list the files.' },
+          { type: 'toolCall', id: 'call_1', name: 'Bash', arguments: { command: 'ls' } },
+        ],
+      },
+      { role: 'toolResult', toolCallId: 'call_1', toolName: 'Bash', content: [{ type: 'text', text: 'file1.txt\nfile2.txt' }] },
+      {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'There are 2 files in the directory.' }],
+      },
+    ]
+    const toolCallMap = new Map([['call_1', { name: 'Bash', args: { command: 'ls' } }]])
+    const completedIds = new Set(['call_1'])
+    const items = buildRenderItems(messages, null, toolCallMap, completedIds)
+
+    expect(items).toHaveLength(4)
+    expect(items[0]?.type).toBe('user-message')
+    expect(items[1]?.type).toBe('text-chunk') // "Sure, let me list the files."
+    expect(items[2]?.type).toBe('tool-result') // ls result
+    expect(items[3]?.type).toBe('text-chunk') // "There are 2 files..."
+  })
+})

package/bundled-plugins/agent/src/utils.ts

@@ -0,0 +1,158 @@
+import type { ContentBlock, RenderItem, AgentMessage, EditToolDetails } from './types'
+
+/**
+ * Split an assistant message's content into render items.
+ * Text/thinking blocks are grouped, toolCall blocks are separated.
+ */
+export function splitAssistantContent(content: ContentBlock[], isStreaming: boolean): RenderItem[] {
+  const items: RenderItem[] = []
+  let textBuffer: ContentBlock[] = []
+
+  for (const block of content) {
+    if (block.type === 'toolCall') {
+      // Flush text buffer
+      if (textBuffer.length > 0) {
+        items.push({ type: 'text-chunk', blocks: textBuffer, isStreaming: false })
+        textBuffer = []
+      }
+      items.push({ type: 'tool-call', id: block.id, name: block.name, args: block.arguments })
+    } else {
+      textBuffer.push(block)
+    }
+  }
+
+  // Flush remaining text (this is the streaming portion if isStreaming)
+  if (textBuffer.length > 0) {
+    items.push({ type: 'text-chunk', blocks: textBuffer, isStreaming })
+  }
+
+  return items
+}
+
+/**
+ * Get text content from content blocks
+ */
+export function getTextFromBlocks(blocks: ContentBlock[]): string {
+  for (const block of blocks) {
+    if (block.type === 'text') return block.text
+  }
+  return ''
+}
+
+/**
+ * Build a map of toolCallId -> toolCall info for matching results to their calls
+ */
+export function buildToolCallMap(messages: AgentMessage[]): Map<string, { name: string; args: Record<string, unknown> }> {
+  const map = new Map<string, { name: string; args: Record<string, unknown> }>()
+  for (const msg of messages) {
+    if (msg.role === 'assistant') {
+      for (const block of msg.content) {
+        if (block.type === 'toolCall') {
+          map.set(block.id, { name: block.name, args: block.arguments })
+        }
+      }
+    }
+  }
+  return map
+}
+
+/**
+ * Get set of toolCallIds that have results in messages
+ */
+export function getCompletedToolCallIds(messages: AgentMessage[]): Set<string> {
+  const set = new Set<string>()
+  for (const msg of messages) {
+    if (msg.role === 'toolResult') {
+      set.add(msg.toolCallId)
+    }
+  }
+  return set
+}
+
+/**
+ * Build render items from messages for display
+ */
+export function buildRenderItems(
+  messages: AgentMessage[],
+  streamingMessageIndex: number | null,
+  toolCallMap: Map<string, { name: string; args: Record<string, unknown> }>,
+  completedToolCallIds: Set<string>
+): RenderItem[] {
+  const items: RenderItem[] = []
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i]!
+    const isStreamingMsg = streamingMessageIndex === i
+
+    if (msg.role === 'user') {
+      // User message
+      const hasText = msg.content.some(b => b.type === 'text' && (b as { type: 'text'; text: string }).text.trim())
+      if (hasText) {
+        items.push({ type: 'user-message', content: msg.content })
+      }
+    }
+    else if (msg.role === 'toolResult') {
+      // Tool result - render as mini shell or diff view
+      const toolCall = toolCallMap.get(msg.toolCallId)
+      const output = getTextFromBlocks(msg.content)
+      const toolName = toolCall?.name || msg.toolName
+
+      let command: string | undefined
+      let diff: string | undefined
+      let filePath: string | undefined
+
+      if (toolCall && (toolName === 'bash' || toolName === 'Bash')) {
+        command = (toolCall.args as { command?: string }).command
+      }
+
+      // Extract diff for Edit/Write tools
+      if (toolName === 'Edit' || toolName === 'edit' || toolName === 'Write' || toolName === 'write') {
+        const details = msg.details as EditToolDetails | undefined
+        if (details?.diff) {
+          diff = details.diff
+        }
+        // Get file path from tool call args
+        if (toolCall) {
+          filePath = (toolCall.args as { file_path?: string; path?: string }).file_path ||
+                     (toolCall.args as { file_path?: string; path?: string }).path
+        }
+      }
+
+      items.push({
+        type: 'tool-result',
+        toolCallId: msg.toolCallId,
+        toolName,
+        command,
+        output,
+        isError: msg.isError || false,
+        diff,
+        filePath,
+      })
+    }
+    else if (msg.role === 'assistant') {
+      // Split assistant message into text chunks and tool calls
+      const splitItems = splitAssistantContent(msg.content, isStreamingMsg)
+
+      for (const item of splitItems) {
+        if (item.type === 'text-chunk') {
+          // Only add if has displayable content
+          const hasText = item.blocks.some(b =>
+            (b.type === 'text' && b.text.trim()) ||
+            (b.type === 'thinking' && (b as { type: 'thinking'; thinking: string }).thinking.trim())
+          )
+          if (hasText) {
+            items.push(item)
+          }
+        } else if (item.type === 'tool-call') {
+          // Only show tool call if we don't have a result for it yet
+          // (the result will be shown instead)
+          if (!completedToolCallIds.has(item.id)) {
+            items.push(item)
+          }
+        }
+      }
+    }
+  }
+
+  return items
+}

package/bundled-plugins/agent/tsconfig.app.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src"]
+}

package/bundled-plugins/agent/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ],
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}

package/bundled-plugins/agent/tsconfig.node.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

package/bundled-plugins/agent/vite.config.ts

@@ -0,0 +1,14 @@
+import path from "path"
+import tailwindcss from "@tailwindcss/vite"
+import react from "@vitejs/plugin-react"
+import { defineConfig } from "vite"
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+})

package/bundled-plugins/agent/vitest.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vitest/config'
+import react from '@vitejs/plugin-react'
+import path from 'path'
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    environment: 'happy-dom',
+    globals: true,
+    include: ['src/**/*.test.{ts,tsx}'],
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+})

package/bundled-plugins/terminal/README.md

@@ -0,0 +1,7 @@
+# Terminal Plugin
+
+A full-featured terminal emulator in your browser. Spawns a real PTY running your shell (zsh, bash, etc.) with proper job control, colors, and scrollback. Multiple clients can view the same terminal session, and scrollback persists across daemon restarts.
+
+**Usage:** Split a panel and select "Terminal". You get a fresh shell in your home directory. Resize works automatically—the PTY adapts to your panel size.
+
+**Vision:** Terminals that live alongside your AI agents in a unified workspace. Split horizontally, run your agent on top, terminal on bottom, and watch them work together.

package/bundled-plugins/terminal/index.html

@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, interactive-widget=resizes-content" />
+    <title>Terminal</title>
+    <style>
+      * {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
+      html, body, #root {
+        width: 100%;
+        height: 100%;
+        overflow: hidden;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>