Open History to see the last commit
1import { describe, expect, it } from 'vitest'
2import { createNodeIsolateDriver, probeIsolatedVm } from '../src/isolate-driver'
3import type { ToolBinding } from '@tanstack/ai-code-mode'
4
5const addonAvailable = probeIsolatedVm().compatible
6
7function makeBinding(
8 name: string,
9 execute: (args: unknown) => Promise<unknown>,
10): ToolBinding {
11 return {
12 name,
13 description: `${name} tool`,
14 inputSchema: { type: 'object', properties: {} },
15 execute,
16 }
17}
18
19describe.skipIf(!addonAvailable)('createNodeIsolateDriver', () => {
20 describe('createContext', () => {
21 it('returns a context with execute and dispose', async () => {
22 const driver = createNodeIsolateDriver()
23 const context = await driver.createContext({ bindings: {} })
24
25 expect(context).toBeDefined()
26 expect(typeof context.execute).toBe('function')
27 expect(typeof context.dispose).toBe('function')
28
29 const result = await context.execute('return 42')
30 expect(result.success).toBe(true)
31 expect(result.value).toBe(42)
32 })
33 })
34
35 describe('execute - basic execution', () => {
36 it('evaluates arithmetic and returns value', async () => {
37 const driver = createNodeIsolateDriver()
38 const context = await driver.createContext({ bindings: {} })
39
40 const result = await context.execute('return 3 + 4')
41
42 expect(result.success).toBe(true)
43 expect(result.value).toBe(7)
44 })
45
46 it('evaluates string operations', async () => {
47 const driver = createNodeIsolateDriver()
48 const context = await driver.createContext({ bindings: {} })
49
50 const result = await context.execute('return "hello" + " " + "world"')
51
52 expect(result.success).toBe(true)
53 expect(result.value).toBe('hello world')
54 })
55
56 it('evaluates async code and returns value', async () => {
57 const driver = createNodeIsolateDriver()
58 const context = await driver.createContext({ bindings: {} })
59
60 const result = await context.execute(`
61 const x = await Promise.resolve(10);
62 return x + 2;
63 `)
64
65 expect(result.success).toBe(true)
66 expect(result.value).toBe(12)
67 })
68
69 it('returns object and array values', async () => {
70 const driver = createNodeIsolateDriver()
71 const context = await driver.createContext({ bindings: {} })
72
73 const result = await context.execute('return { a: 1, b: [2, 3] }')
74
75 expect(result.success).toBe(true)
76 expect(result.value).toEqual({ a: 1, b: [2, 3] })
77 })
78 })
79
80 describe('execute - tool bindings', () => {
81 it('injects tool and executes tool call', async () => {
82 const add = makeBinding('add', async (args: unknown) => {
83 const { a, b } = args as { a: number; b: number }
84 return a + b
85 })
86
87 const driver = createNodeIsolateDriver()
88 const context = await driver.createContext({
89 bindings: { add },
90 })
91
92 const result = await context.execute(`
93 const sum = await add({ a: 2, b: 3 });
94 return sum;
95 `)
96
97 expect(result.success).toBe(true)
98 expect(result.value).toBe(5)
99 })
100
101 it('supports multiple tools in one execution', async () => {
102 const getA = makeBinding('getA', async () => 'A')
103 const getB = makeBinding('getB', async () => 'B')
104
105 const driver = createNodeIsolateDriver()
106 const context = await driver.createContext({
107 bindings: { getA, getB },
108 })
109
110 const result = await context.execute(`
111 const a = await getA({});
112 const b = await getB({});
113 return a + b;
114 `)
115
116 expect(result.success).toBe(true)
117 expect(result.value).toBe('AB')
118 })
119
120 it('surfaces tool execution errors', async () => {
121 const failTool = makeBinding('failTool', async () => {
122 throw new Error('Tool failed')
123 })
124
125 const driver = createNodeIsolateDriver()
126 const context = await driver.createContext({
127 bindings: { failTool },
128 })
129
130 const result = await context.execute('return await failTool({})')
131
132 expect(result.success).toBe(false)
133 expect(result.error?.message).toContain('Tool failed')
134 })
135 })
136
137 describe('execute - timeout', () => {
138 it('returns timeout error when code runs too long', async () => {
139 const driver = createNodeIsolateDriver({ timeout: 50 })
140 const context = await driver.createContext({
141 bindings: {},
142 timeout: 50,
143 })
144
145 const result = await context.execute(`
146 const start = Date.now();
147 while (Date.now() - start < 500) {
148 // spin
149 }
150 return 1;
151 `)
152
153 expect(result.success).toBe(false)
154 expect(result.error?.name).toBeDefined()
155 })
156 })
157
158 describe('execute - error handling', () => {
159 it('returns error for syntax errors', async () => {
160 const driver = createNodeIsolateDriver()
161 const context = await driver.createContext({ bindings: {} })
162
163 const result = await context.execute('syntax error!!!')
164
165 expect(result.success).toBe(false)
166 expect(result.error?.message).toBeDefined()
167 })
168
169 it('returns error for runtime errors', async () => {
170 const driver = createNodeIsolateDriver()
171 const context = await driver.createContext({ bindings: {} })
172
173 const result = await context.execute('throw new Error("oops")')
174
175 expect(result.success).toBe(false)
176 expect(result.error?.message).toContain('oops')
177 })
178 })
179
180 describe('execute - console capture', () => {
181 it('captures console.log in logs', async () => {
182 const driver = createNodeIsolateDriver()
183 const context = await driver.createContext({ bindings: {} })
184
185 const result = await context.execute(`
186 console.log("hello");
187 console.log("world");
188 return 1;
189 `)
190
191 expect(result.success).toBe(true)
192 expect(result.logs).toContain('hello')
193 expect(result.logs).toContain('world')
194 })
195
196 it('captures console.error with ERROR prefix', async () => {
197 const driver = createNodeIsolateDriver()
198 const context = await driver.createContext({ bindings: {} })
199
200 const result = await context.execute(`
201 console.error("fail");
202 return 1;
203 `)
204
205 expect(result.success).toBe(true)
206 expect(result.logs?.some((l) => l.includes('fail'))).toBe(true)
207 })
208 })
209
210 describe('memoryLimit config', () => {
211 it('accepts memoryLimit in createContext', async () => {
212 const driver = createNodeIsolateDriver({ memoryLimit: 64 })
213 const context = await driver.createContext({
214 bindings: {},
215 memoryLimit: 32,
216 })
217
218 const result = await context.execute('return 1')
219 expect(result.success).toBe(true)
220 expect(result.value).toBe(1)
221 })
222 })
223
224 describe('dispose', () => {
225 it('execute returns DisposedError after dispose', async () => {
226 const driver = createNodeIsolateDriver()
227 const context = await driver.createContext({ bindings: {} })
228
229 await context.dispose()
230
231 const result = await context.execute('return 1')
232
233 expect(result.success).toBe(false)
234 expect(result.error?.name).toBe('DisposedError')
235 expect(result.error?.message).toContain('disposed')
236 })
237 })
238
239 describe('memory isolation', () => {
240 it('contexts do not share state', async () => {
241 const driver = createNodeIsolateDriver()
242 const ctx1 = await driver.createContext({ bindings: {} })
243 const ctx2 = await driver.createContext({ bindings: {} })
244
245 await ctx1.execute('globalThis.__secret = 100; return 1')
246 const result2 = await ctx2.execute('return typeof globalThis.__secret')
247
248 expect(result2.success).toBe(true)
249 expect(result2.value).toBe('undefined')
250
251 await ctx1.dispose()
252 await ctx2.dispose()
253 })
254 })
255})