wehub-resource-sync
634 lines
24 KiB
JavaScript
634 lines
24 KiB
JavaScript
const { test, describe, before } = require('node:test')
|
|
const assert = require('assert/strict')
|
|
const axios = require('axios')
|
|
|
|
const serverUrl = 'http://127.0.0.1:30837/mcp'
|
|
|
|
// Helper function to make HTTP requests
|
|
async function makeHttpRequest (method, urlStr, data = null, headers = {}) {
|
|
try {
|
|
const response = await axios({
|
|
method: method.toUpperCase(),
|
|
url: urlStr,
|
|
data,
|
|
headers
|
|
})
|
|
return {
|
|
status: response.status,
|
|
headers: response.headers,
|
|
data: response.data
|
|
}
|
|
} catch (error) {
|
|
if (error.response) {
|
|
const err = new Error(`Request failed with status ${error.response.status}`)
|
|
err.response = {
|
|
status: error.response.status,
|
|
headers: error.response.headers,
|
|
data: error.response.data
|
|
}
|
|
throw err
|
|
} else {
|
|
throw error
|
|
}
|
|
}
|
|
}
|
|
|
|
// Helper function to initialize MCP session
|
|
async function initSession () {
|
|
const initializeRequest = {
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
method: 'initialize',
|
|
params: {
|
|
protocolVersion: '2024-11-05',
|
|
capabilities: {},
|
|
clientInfo: {
|
|
name: 'electerm-test-client',
|
|
version: '1.0.0'
|
|
}
|
|
}
|
|
}
|
|
|
|
const response = await makeHttpRequest('post', serverUrl, initializeRequest, {
|
|
'Content-Type': 'application/json',
|
|
Accept: 'application/json, text/event-stream'
|
|
})
|
|
|
|
const sid = response.headers['mcp-session-id']
|
|
assert.ok(sid && sid !== 'null', `initSession: expected a real session ID but got: ${sid}`)
|
|
return sid
|
|
}
|
|
|
|
// Helper: call a tool and parse the SSE response into JSON result/error
|
|
async function callTool (sid, id, toolName, args) {
|
|
const response = await makeHttpRequest('post', serverUrl, {
|
|
jsonrpc: '2.0',
|
|
id,
|
|
method: 'tools/call',
|
|
params: { name: toolName, arguments: args }
|
|
}, {
|
|
'Content-Type': 'application/json',
|
|
Accept: 'application/json, text/event-stream',
|
|
'mcp-session-id': sid
|
|
})
|
|
assert.equal(response.status, 200)
|
|
const dataLine = response.data.split('\n').find(l => l.startsWith('data: '))
|
|
assert.ok(dataLine, `No data line in SSE response for ${toolName}`)
|
|
const jsonData = JSON.parse(dataLine.substring(6))
|
|
assert.equal(jsonData.jsonrpc, '2.0')
|
|
assert.equal(jsonData.id, id)
|
|
return jsonData
|
|
}
|
|
|
|
// Helper: check if renderer is available by trying list_electerm_tabs
|
|
async function checkRenderer (sid) {
|
|
const jsonData = await callTool(sid, 999, 'list_electerm_tabs', {})
|
|
return !jsonData.error
|
|
}
|
|
|
|
describe('mcp-widget', function () {
|
|
let sessionId = null
|
|
let hasRenderer = false
|
|
|
|
before(async () => {
|
|
sessionId = await initSession()
|
|
hasRenderer = await checkRenderer(sessionId)
|
|
if (!hasRenderer) {
|
|
console.log('No renderer detected — renderer-dependent tests will be skipped')
|
|
}
|
|
})
|
|
|
|
// ─── Protocol-level tests (no renderer needed) ──────────────────────────
|
|
|
|
test('should be accessible at http://127.0.0.1:30837/mcp with default settings', { timeout: 100000 }, async function () {
|
|
const optionsResponse = await makeHttpRequest('options', serverUrl)
|
|
assert.equal(optionsResponse.status, 204)
|
|
assert.equal(optionsResponse.headers['access-control-allow-origin'], undefined)
|
|
assert.ok(optionsResponse.headers['access-control-allow-methods'].includes('POST'))
|
|
assert.ok(optionsResponse.headers['access-control-allow-methods'].includes('GET'))
|
|
assert.ok(optionsResponse.headers['access-control-allow-methods'].includes('DELETE'))
|
|
assert.ok(optionsResponse.headers['access-control-allow-headers'].includes('mcp-session-id'))
|
|
})
|
|
|
|
test('should respond to MCP initialize request', { timeout: 100000 }, async function () {
|
|
const initializeRequest = {
|
|
jsonrpc: '2.0',
|
|
id: 1,
|
|
method: 'initialize',
|
|
params: {
|
|
protocolVersion: '2024-11-05',
|
|
capabilities: {},
|
|
clientInfo: {
|
|
name: 'electerm-test-client',
|
|
version: '1.0.0'
|
|
}
|
|
}
|
|
}
|
|
|
|
const response = await makeHttpRequest('post', serverUrl, initializeRequest, {
|
|
'Content-Type': 'application/json',
|
|
Accept: 'application/json, text/event-stream'
|
|
})
|
|
|
|
assert.equal(response.status, 200)
|
|
assert.equal(response.headers['content-type'], 'text/event-stream')
|
|
const returnedSessionId = response.headers['mcp-session-id']
|
|
assert.ok(returnedSessionId, 'mcp-session-id header is missing')
|
|
assert.notEqual(returnedSessionId, 'null', 'mcp-session-id must not be the string "null"')
|
|
assert.match(returnedSessionId, /^[\w-]+$/, 'mcp-session-id must be a valid identifier')
|
|
|
|
// Parse SSE response
|
|
const sseData = response.data
|
|
assert.ok(sseData.includes('event: message'))
|
|
assert.ok(sseData.includes('data: '))
|
|
|
|
const dataLine = sseData.split('\n').find(line => line.startsWith('data: '))
|
|
assert.ok(dataLine)
|
|
const jsonData = JSON.parse(dataLine.substring(6))
|
|
|
|
assert.equal(jsonData.jsonrpc, '2.0')
|
|
assert.equal(jsonData.id, 1)
|
|
assert.ok(jsonData.result)
|
|
assert.equal(jsonData.result.protocolVersion, '2024-11-05')
|
|
assert.ok(jsonData.result.serverInfo)
|
|
assert.equal(jsonData.result.serverInfo.name, 'electerm-mcp-server')
|
|
})
|
|
|
|
test('should list available tools', { timeout: 100000 }, async function () {
|
|
assert.ok(sessionId)
|
|
|
|
const toolsRequest = {
|
|
jsonrpc: '2.0',
|
|
id: 2,
|
|
method: 'tools/list',
|
|
params: {}
|
|
}
|
|
|
|
const response = await makeHttpRequest('post', serverUrl, toolsRequest, {
|
|
'Content-Type': 'application/json',
|
|
Accept: 'application/json, text/event-stream',
|
|
'mcp-session-id': sessionId
|
|
})
|
|
|
|
assert.equal(response.status, 200)
|
|
assert.equal(response.headers['content-type'], 'text/event-stream')
|
|
|
|
const sseData = response.data
|
|
assert.ok(sseData.includes('event: message'))
|
|
assert.ok(sseData.includes('data: '))
|
|
|
|
const dataLine = sseData.split('\n').find(line => line.startsWith('data: '))
|
|
assert.ok(dataLine)
|
|
const jsonData = JSON.parse(dataLine.substring(6))
|
|
|
|
assert.equal(jsonData.jsonrpc, '2.0')
|
|
assert.equal(jsonData.id, 2)
|
|
assert.ok(jsonData.result)
|
|
assert.ok(Array.isArray(jsonData.result.tools))
|
|
assert.ok(jsonData.result.tools.length > 0)
|
|
|
|
const toolNames = jsonData.result.tools.map(tool => tool.name)
|
|
assert.ok(toolNames.includes('list_electerm_tabs'))
|
|
assert.ok(toolNames.includes('get_electerm_active_tab'))
|
|
assert.ok(toolNames.includes('send_electerm_terminal_command'))
|
|
assert.ok(toolNames.includes('get_electerm_terminal_status'))
|
|
assert.ok(toolNames.includes('cancel_electerm_terminal_command'))
|
|
assert.ok(toolNames.includes('run_electerm_background_command'))
|
|
assert.ok(toolNames.includes('get_electerm_background_task_status'))
|
|
assert.ok(toolNames.includes('get_electerm_background_task_log'))
|
|
assert.ok(toolNames.includes('cancel_electerm_background_task'))
|
|
})
|
|
|
|
// ─── Tool call protocol tests ───────────────────────────────────────────
|
|
|
|
test('should return error when calling tool without renderer', { timeout: 100000 }, async function () {
|
|
assert.ok(sessionId)
|
|
|
|
const jsonData = await callTool(sessionId, 3, 'open_electerm_local_terminal', {})
|
|
|
|
if (hasRenderer) {
|
|
// With renderer: tool call should succeed
|
|
assert.ok(jsonData.result, 'Expected success result with renderer')
|
|
const result = JSON.parse(jsonData.result.content[0].text)
|
|
assert.equal(result.success, true)
|
|
} else {
|
|
// Without renderer: should get a JSON-RPC error
|
|
assert.ok(jsonData.error, 'Expected error without renderer')
|
|
assert.ok(jsonData.error.code !== undefined, 'Error must have a code')
|
|
assert.ok(jsonData.error.message.length > 0, 'Error must have a message')
|
|
}
|
|
})
|
|
|
|
test('should handle multiple tool calls in sequence', { timeout: 100000 }, async function () {
|
|
assert.ok(sessionId)
|
|
|
|
const toolNames = ['list_electerm_tabs', 'get_electerm_active_tab', 'get_electerm_terminal_selection']
|
|
|
|
for (let i = 0; i < toolNames.length; i++) {
|
|
const jsonData = await callTool(sessionId, 10 + i, toolNames[i], {})
|
|
|
|
// Each call must return a valid JSON-RPC response (result or error)
|
|
assert.ok(
|
|
jsonData.result || jsonData.error,
|
|
`Tool ${toolNames[i]} must return either result or error`
|
|
)
|
|
}
|
|
})
|
|
|
|
// ─── Renderer-dependent terminal tests ──────────────────────────────────
|
|
|
|
test('should open local terminal and run command', { timeout: 100000 }, async function () {
|
|
if (!hasRenderer) return test.skip('No renderer available')
|
|
|
|
// Step 1: Open a local terminal
|
|
const openData = await callTool(sessionId, 20, 'open_electerm_local_terminal', {})
|
|
assert.ok(openData.result, 'open_local_terminal should succeed')
|
|
const openResult = JSON.parse(openData.result.content[0].text)
|
|
assert.equal(openResult.success, true)
|
|
assert.ok(openResult.message.includes('local terminal'))
|
|
|
|
// Wait for terminal to initialize
|
|
await new Promise(resolve => setTimeout(resolve, 3000))
|
|
|
|
// Step 2: Send a command
|
|
const uniqueId = Date.now()
|
|
const testCommand = `echo "MCP_TEST_${uniqueId}"`
|
|
|
|
const cmdData = await callTool(sessionId, 21, 'send_electerm_terminal_command', {
|
|
command: testCommand
|
|
})
|
|
assert.ok(cmdData.result, 'send_terminal_command should succeed')
|
|
const cmdResult = JSON.parse(cmdData.result.content[0].text)
|
|
assert.equal(cmdResult.success, true)
|
|
|
|
// Wait for command to execute
|
|
await new Promise(resolve => setTimeout(resolve, 2000))
|
|
|
|
// Step 3: Get terminal output and verify command was executed
|
|
const outputData = await callTool(sessionId, 22, 'get_electerm_terminal_output', {
|
|
lines: 20
|
|
})
|
|
assert.ok(outputData.result, 'get_terminal_output should succeed')
|
|
const outputResult = JSON.parse(outputData.result.content[0].text)
|
|
assert.ok(outputResult.output !== undefined)
|
|
assert.ok(outputResult.lineCount > 0)
|
|
assert.ok(
|
|
outputResult.output.includes(`MCP_TEST_${uniqueId}`),
|
|
`Expected command output "MCP_TEST_${uniqueId}" in terminal`
|
|
)
|
|
})
|
|
|
|
test('should get terminal output', { timeout: 100000 }, async function () {
|
|
if (!hasRenderer) return test.skip('No renderer available')
|
|
|
|
const jsonData = await callTool(sessionId, 30, 'get_electerm_terminal_output', {
|
|
lines: 10
|
|
})
|
|
assert.ok(jsonData.result, 'get_terminal_output should succeed')
|
|
const result = JSON.parse(jsonData.result.content[0].text)
|
|
assert.ok(result.output !== undefined)
|
|
assert.ok(result.tabId !== undefined)
|
|
assert.equal(typeof result.lineCount, 'number')
|
|
})
|
|
|
|
test('should create SSH bookmark, connect, run command and get output', { timeout: 100000 }, async function () {
|
|
if (!hasRenderer) return test.skip('No renderer available')
|
|
|
|
const {
|
|
TEST_HOST,
|
|
TEST_PASS,
|
|
TEST_USER,
|
|
TEST_PORT
|
|
} = require('../e2e/common/env')
|
|
|
|
const uniqueId = Date.now()
|
|
const bookmarkTitle = `MCP1_SSH_Test_${uniqueId}`
|
|
|
|
// Step 1: Create SSH bookmark
|
|
const addData = await callTool(sessionId, 40, 'add_electerm_bookmark_ssh', {
|
|
title: bookmarkTitle,
|
|
host: TEST_HOST,
|
|
port: parseInt(TEST_PORT, 10),
|
|
username: TEST_USER,
|
|
password: TEST_PASS
|
|
})
|
|
assert.ok(addData.result, 'add_bookmark should succeed')
|
|
const addResult = JSON.parse(addData.result.content[0].text)
|
|
assert.equal(addResult.success, true)
|
|
assert.ok(addResult.id !== undefined)
|
|
const bookmarkId = addResult.id
|
|
|
|
try {
|
|
// Step 2: Open/connect to the bookmark
|
|
const openData = await callTool(sessionId, 41, 'open_electerm_bookmark', {
|
|
id: bookmarkId
|
|
})
|
|
assert.ok(openData.result, 'open_bookmark should succeed')
|
|
const openResult = JSON.parse(openData.result.content[0].text)
|
|
assert.equal(openResult.success, true)
|
|
|
|
// Wait for SSH connection to establish
|
|
await new Promise(resolve => setTimeout(resolve, 8000))
|
|
|
|
// Step 3: Send a command with retry
|
|
const testMarker = `SSH_MCP_TEST_${uniqueId}`
|
|
const testCommand = `echo "${testMarker}"`
|
|
|
|
let cmdResult = null
|
|
for (let attempt = 1; attempt <= 3; attempt++) {
|
|
const cmdData = await callTool(sessionId, 42, 'send_electerm_terminal_command', {
|
|
command: testCommand
|
|
})
|
|
if (cmdData.error) {
|
|
if (attempt === 3) {
|
|
assert.fail(`send_command failed after 3 attempts: ${cmdData.error.message}`)
|
|
}
|
|
await new Promise(resolve => setTimeout(resolve, 2000))
|
|
continue
|
|
}
|
|
cmdResult = JSON.parse(cmdData.result.content[0].text)
|
|
break
|
|
}
|
|
assert.equal(cmdResult.success, true)
|
|
|
|
// Wait for command to execute
|
|
await new Promise(resolve => setTimeout(resolve, 2000))
|
|
|
|
// Step 4: Get terminal output and verify command was executed
|
|
const outputData = await callTool(sessionId, 43, 'get_electerm_terminal_output', {
|
|
lines: 30
|
|
})
|
|
assert.ok(outputData.result, 'get_terminal_output should succeed')
|
|
const outputResult = JSON.parse(outputData.result.content[0].text)
|
|
assert.ok(outputResult.output !== undefined)
|
|
assert.ok(outputResult.lineCount > 0)
|
|
assert.ok(
|
|
outputResult.output.includes(testMarker),
|
|
`Expected SSH command output "${testMarker}" in terminal`
|
|
)
|
|
} finally {
|
|
// Step 5: Clean up - delete the test bookmark
|
|
const deleteData = await callTool(sessionId, 44, 'delete_electerm_bookmark', {
|
|
id: bookmarkId
|
|
})
|
|
if (deleteData.result) {
|
|
const deleteResult = JSON.parse(deleteData.result.content[0].text)
|
|
assert.equal(deleteResult.success, true)
|
|
}
|
|
|
|
// Step 6: Verify the bookmark was actually deleted
|
|
const listData = await callTool(sessionId, 45, 'list_electerm_bookmarks', {})
|
|
assert.ok(listData.result, 'list_bookmarks should succeed')
|
|
const bookmarks = JSON.parse(listData.result.content[0].text)
|
|
const deletedBookmark = bookmarks.find(b => b.id === bookmarkId)
|
|
assert.ok(!deletedBookmark, `Bookmark with ID ${bookmarkId} should have been deleted but was found`)
|
|
}
|
|
})
|
|
|
|
test('should create Telnet bookmark', { timeout: 100000 }, async function () {
|
|
if (!hasRenderer) return test.skip('No renderer available')
|
|
|
|
const uniqueId = Date.now()
|
|
const bookmarkTitle = `MCP1_Telnet_Test_${uniqueId}`
|
|
|
|
// Create Telnet bookmark
|
|
const addData = await callTool(sessionId, 50, 'add_electerm_bookmark_telnet', {
|
|
title: bookmarkTitle,
|
|
host: '127.0.0.1',
|
|
port: 23,
|
|
username: 'testuser',
|
|
password: 'testpass'
|
|
})
|
|
assert.ok(addData.result, 'add_bookmark should succeed')
|
|
const addResult = JSON.parse(addData.result.content[0].text)
|
|
assert.equal(addResult.success, true)
|
|
assert.ok(addResult.id !== undefined)
|
|
const bookmarkId = addResult.id
|
|
|
|
// Verify bookmark was created by listing bookmarks
|
|
const listData = await callTool(sessionId, 51, 'list_electerm_bookmarks', {})
|
|
assert.ok(listData.result, 'list_bookmarks should succeed')
|
|
const bookmarks = JSON.parse(listData.result.content[0].text)
|
|
const createdBookmark = bookmarks.find(b => b.id === bookmarkId)
|
|
assert.ok(createdBookmark, `Bookmark with ID ${bookmarkId} not found in list`)
|
|
assert.equal(createdBookmark.title, bookmarkTitle)
|
|
assert.equal(createdBookmark.type, 'telnet')
|
|
})
|
|
|
|
// ─── Direct tab open tests ─────────────────────────────────────────────
|
|
|
|
test('should open SSH tab directly without bookmark, run command and get output', { timeout: 100000 }, async function () {
|
|
if (!hasRenderer) return test.skip('No renderer available')
|
|
|
|
const {
|
|
TEST_HOST,
|
|
TEST_PASS,
|
|
TEST_USER,
|
|
TEST_PORT
|
|
} = require('../e2e/common/env')
|
|
|
|
const uniqueId = Date.now()
|
|
const tabTitle = `MCP_Direct_SSH_${uniqueId}`
|
|
|
|
// Step 1: Open SSH tab directly (no bookmark created)
|
|
const openData = await callTool(sessionId, 70, 'open_electerm_tab_ssh', {
|
|
title: tabTitle,
|
|
host: TEST_HOST,
|
|
port: parseInt(TEST_PORT, 10),
|
|
username: TEST_USER,
|
|
password: TEST_PASS
|
|
})
|
|
assert.ok(openData.result, 'open_tab_ssh should succeed')
|
|
const openResult = JSON.parse(openData.result.content[0].text)
|
|
assert.equal(openResult.success, true)
|
|
assert.ok(openResult.tabId !== undefined)
|
|
assert.equal(openResult.type, 'ssh')
|
|
|
|
// Wait for SSH connection to establish
|
|
await new Promise(resolve => setTimeout(resolve, 8000))
|
|
|
|
try {
|
|
// Step 2: Send a command with retry
|
|
const testMarker = `SSH_DIRECT_TEST_${uniqueId}`
|
|
const testCommand = `echo "${testMarker}"`
|
|
|
|
let cmdResult = null
|
|
for (let attempt = 1; attempt <= 3; attempt++) {
|
|
const cmdData = await callTool(sessionId, 71, 'send_electerm_terminal_command', {
|
|
command: testCommand
|
|
})
|
|
if (cmdData.error) {
|
|
if (attempt === 3) {
|
|
assert.fail(`send_command failed after 3 attempts: ${cmdData.error.message}`)
|
|
}
|
|
await new Promise(resolve => setTimeout(resolve, 2000))
|
|
continue
|
|
}
|
|
cmdResult = JSON.parse(cmdData.result.content[0].text)
|
|
break
|
|
}
|
|
assert.equal(cmdResult.success, true)
|
|
|
|
// Wait for command to execute
|
|
await new Promise(resolve => setTimeout(resolve, 2000))
|
|
|
|
// Step 3: Get terminal output and verify command was executed
|
|
const outputData = await callTool(sessionId, 72, 'get_electerm_terminal_output', {
|
|
lines: 30
|
|
})
|
|
assert.ok(outputData.result, 'get_terminal_output should succeed')
|
|
const outputResult = JSON.parse(outputData.result.content[0].text)
|
|
assert.ok(outputResult.output !== undefined)
|
|
assert.ok(
|
|
outputResult.output.includes(testMarker),
|
|
`Expected SSH command output "${testMarker}" in terminal`
|
|
)
|
|
|
|
// Step 4: Verify no bookmark was created for this connection
|
|
const listData = await callTool(sessionId, 73, 'list_electerm_bookmarks', {})
|
|
assert.ok(listData.result, 'list_bookmarks should succeed')
|
|
const bookmarks = JSON.parse(listData.result.content[0].text)
|
|
const foundBookmark = bookmarks.find(b => b.title === tabTitle)
|
|
assert.ok(!foundBookmark, `No bookmark should be created for direct tab open, but found: ${JSON.stringify(foundBookmark)}`)
|
|
} finally {
|
|
// Step 5: Close the tab
|
|
const tabId = openResult.tabId
|
|
await callTool(sessionId, 74, 'close_electerm_tab', { tabId })
|
|
}
|
|
})
|
|
|
|
test('should list direct open tools in tools/list', { timeout: 100000 }, async function () {
|
|
assert.ok(sessionId)
|
|
|
|
const toolsRequest = {
|
|
jsonrpc: '2.0',
|
|
id: 75,
|
|
method: 'tools/list',
|
|
params: {}
|
|
}
|
|
|
|
const response = await makeHttpRequest('post', serverUrl, toolsRequest, {
|
|
'Content-Type': 'application/json',
|
|
Accept: 'application/json, text/event-stream',
|
|
'mcp-session-id': sessionId
|
|
})
|
|
|
|
assert.equal(response.status, 200)
|
|
const dataLine = response.data.split('\n').find(l => l.startsWith('data: '))
|
|
const jsonData = JSON.parse(dataLine.substring(6))
|
|
const toolNames = jsonData.result.tools.map(tool => tool.name)
|
|
|
|
assert.ok(toolNames.includes('open_electerm_tab_ssh'), 'Missing open_electerm_tab_ssh')
|
|
assert.ok(toolNames.includes('open_electerm_tab_telnet'), 'Missing open_electerm_tab_telnet')
|
|
assert.ok(toolNames.includes('open_electerm_tab_serial'), 'Missing open_electerm_tab_serial')
|
|
assert.ok(toolNames.includes('open_electerm_tab_local'), 'Missing open_electerm_tab_local')
|
|
})
|
|
|
|
// ─── onData test ────────────────────────────────────────────────────────
|
|
|
|
test('list_tabs should include onData field for each tab', { timeout: 100000 }, async function () {
|
|
if (!hasRenderer) return test.skip('No renderer available')
|
|
|
|
const jsonData = await callTool(sessionId, 60, 'list_electerm_tabs', {})
|
|
assert.ok(jsonData.result, 'list_tabs should succeed')
|
|
|
|
const tabs = JSON.parse(jsonData.result.content[0].text)
|
|
assert.ok(Array.isArray(tabs), 'Expected an array of tabs')
|
|
|
|
for (const tab of tabs) {
|
|
assert.ok('onData' in tab, `Tab ${tab.id} is missing the onData field`)
|
|
assert.equal(typeof tab.onData, 'string', `onData for tab ${tab.id} should be string`)
|
|
}
|
|
})
|
|
|
|
// ─── Terminal idle tests ────────────────────────────────────────────────
|
|
|
|
test('should wait for terminal idle after a quick echo command', { timeout: 100000 }, async function () {
|
|
if (!hasRenderer) return test.skip('No renderer available')
|
|
|
|
const openData = await callTool(sessionId, 61, 'open_electerm_local_terminal', {})
|
|
assert.ok(openData.result, 'open_local_terminal should succeed')
|
|
const openResult = JSON.parse(openData.result.content[0].text)
|
|
assert.equal(openResult.success, true)
|
|
|
|
await new Promise(resolve => setTimeout(resolve, 3000))
|
|
|
|
const marker = `IDLE_TEST_${Date.now()}`
|
|
|
|
const sendData = await callTool(sessionId, 62, 'send_electerm_terminal_command', {
|
|
command: `echo "${marker}"`
|
|
})
|
|
assert.ok(sendData.result, 'send_command should succeed')
|
|
|
|
const waitData = await callTool(sessionId, 63, 'wait_for_electerm_terminal_idle', {
|
|
timeout: 20000,
|
|
lines: 30
|
|
})
|
|
assert.ok(waitData.result, 'wait_for_terminal_idle should succeed')
|
|
|
|
const waitResult = JSON.parse(waitData.result.content[0].text)
|
|
assert.equal(waitResult.timedOut, false, 'Expected terminal to become idle before timeout')
|
|
assert.ok(waitResult.elapsed >= 0, 'Expected non-negative elapsed time')
|
|
assert.equal(typeof waitResult.lineCount, 'number')
|
|
assert.equal(typeof waitResult.output, 'string')
|
|
assert.ok(
|
|
waitResult.output.includes(marker),
|
|
`Expected echo output "${marker}" in terminal after idle wait`
|
|
)
|
|
})
|
|
|
|
test('should correctly wait for a longer-running command to finish', { timeout: 100000 }, async function () {
|
|
if (!hasRenderer) return test.skip('No renderer available')
|
|
|
|
const openData = await callTool(sessionId, 64, 'open_electerm_local_terminal', {})
|
|
assert.ok(openData.result, 'open_local_terminal should succeed')
|
|
await new Promise(resolve => setTimeout(resolve, 3000))
|
|
|
|
const marker = `SLOW_TEST_${Date.now()}`
|
|
|
|
const sendData = await callTool(sessionId, 65, 'send_electerm_terminal_command', {
|
|
command: `sleep 5 && echo "${marker}"`
|
|
})
|
|
assert.ok(sendData.result, 'send_command should succeed')
|
|
|
|
const waitData = await callTool(sessionId, 66, 'wait_for_electerm_terminal_idle', {
|
|
timeout: 30000,
|
|
lines: 30
|
|
})
|
|
assert.ok(waitData.result, 'wait_for_terminal_idle should succeed')
|
|
|
|
const waitResult = JSON.parse(waitData.result.content[0].text)
|
|
assert.equal(waitResult.timedOut, false, 'Expected terminal to become idle before 30s timeout')
|
|
assert.ok(waitResult.elapsed >= 5000, `Expected at least 5s elapsed but got ${waitResult.elapsed}ms`)
|
|
assert.ok(
|
|
waitResult.output.includes(marker),
|
|
`Expected slow command output "${marker}" after idle wait`
|
|
)
|
|
})
|
|
|
|
test('should return timedOut:true when terminal never becomes idle within timeout', { timeout: 100000 }, async function () {
|
|
if (!hasRenderer) return test.skip('No renderer available')
|
|
|
|
const openData = await callTool(sessionId, 67, 'open_electerm_local_terminal', {})
|
|
assert.ok(openData.result, 'open_local_terminal should succeed')
|
|
await new Promise(resolve => setTimeout(resolve, 3000))
|
|
|
|
const sendData = await callTool(sessionId, 68, 'send_electerm_terminal_command', {
|
|
command: 'ping -c 30 localhost'
|
|
})
|
|
assert.ok(sendData.result, 'send_command should succeed')
|
|
|
|
const waitData = await callTool(sessionId, 69, 'wait_for_electerm_terminal_idle', {
|
|
timeout: 8000,
|
|
lines: 20,
|
|
minWait: 500
|
|
})
|
|
assert.ok(waitData.result, 'wait_for_terminal_idle should succeed')
|
|
|
|
const waitResult = JSON.parse(waitData.result.content[0].text)
|
|
assert.equal(waitResult.timedOut, true, 'Expected timedOut:true when command keeps running')
|
|
assert.ok(waitResult.elapsed >= 8000, `Expected at least 8s elapsed but got ${waitResult.elapsed}ms`)
|
|
assert.equal(typeof waitResult.output, 'string', 'Should still return whatever output is in buffer')
|
|
})
|
|
})
|