luca 2.0.0 → 3.0.0

package/test/container-link.test.ts

@@ -0,0 +1,274 @@
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import { NodeContainer } from '../src/node/container'
+import { MessageTypes, type LinkMessage, type ContainerLink } from '../src/node/features/container-link'
+
+// Local helper for tests — mirrors the protocol message format
+let _testMsgCounter = 0
+function createTestMessage<T = any>(type: string, data?: T, token?: string): LinkMessage<T> {
+  return {
+    type: type as any,
+    id: `test-${Date.now()}-${++_testMsgCounter}`,
+    timestamp: Date.now(),
+    ...(token != null ? { token } : {}),
+    ...(data != null ? { data } : {}),
+  }
+}
+
+// Helper: connect and register using Bun's native WebSocket
+async function connectAndRegister(port: number, uuid: string, opts?: { url?: string; capabilities?: string[]; meta?: Record<string, any> }) {
+  const ws = new WebSocket(`ws://localhost:${port}`)
+
+  const token = await new Promise<string>((resolve, reject) => {
+    ws.onopen = () => {
+      ws.send(JSON.stringify(createTestMessage(MessageTypes.register, {
+        uuid,
+        url: opts?.url,
+        capabilities: opts?.capabilities,
+        meta: opts?.meta,
+      })))
+    }
+    ws.onmessage = (event: MessageEvent) => {
+      const msg = JSON.parse(event.data)
+      if (msg.type === 'registered') resolve(msg.data.token)
+      if (msg.type === 'error') reject(new Error(msg.data?.message))
+    }
+    ws.onerror = () => reject(new Error('WS error'))
+    setTimeout(() => reject(new Error('Registration timeout')), 3000)
+  })
+
+  return { ws, token }
+}
+
+function closeWs(ws: WebSocket): Promise<void> {
+  return new Promise((resolve) => {
+    if (ws.readyState === WebSocket.CLOSED) { resolve(); return }
+    ws.onclose = () => resolve()
+    ws.close()
+    setTimeout(resolve, 200)
+  })
+}
+
+describe('link message construction', () => {
+  it('generates unique ids', () => {
+    const a = createTestMessage(MessageTypes.ping)
+    const b = createTestMessage(MessageTypes.ping)
+    expect(a.id).not.toBe(b.id)
+  })
+
+  it('sets timestamp', () => {
+    const before = Date.now()
+    const msg = createTestMessage(MessageTypes.eval, { code: '1+1' })
+    expect(msg.timestamp).toBeGreaterThanOrEqual(before)
+    expect(msg.timestamp).toBeLessThanOrEqual(Date.now())
+  })
+
+  it('includes type and data', () => {
+    const msg = createTestMessage(MessageTypes.event, { eventName: 'click', data: { x: 1 } }, 'tok123')
+    expect(msg.type).toBe('event')
+    expect(msg.data).toEqual({ eventName: 'click', data: { x: 1 } })
+    expect(msg.token).toBe('tok123')
+  })
+
+  it('omits token when not provided', () => {
+    const msg = createTestMessage(MessageTypes.ping)
+    expect(msg.token).toBeUndefined()
+  })
+})
+
+describe('ContainerLink (node-side)', () => {
+  let container: NodeContainer
+  let link: ContainerLink
+  let port: number
+  const openSockets: WebSocket[] = []
+
+  beforeEach(async () => {
+    container = new NodeContainer({ cwd: process.cwd() })
+    const networking = container.feature('networking')
+    port = await networking.findOpenPort(9100)
+    link = container.feature('containerLink', { enable: true, port }) as ContainerLink
+  })
+
+  afterEach(async () => {
+    for (const ws of openSockets) {
+      await closeWs(ws).catch(() => {})
+    }
+    openSockets.length = 0
+    await link.stop().catch(() => {})
+  })
+
+  it('instantiates with correct defaults', () => {
+    expect(link).toBeDefined()
+    expect(link.isListening).toBe(false)
+    expect(link.connectionCount).toBe(0)
+  })
+
+  it('generates unique tokens', () => {
+    const tokens = new Set<string>()
+    for (let i = 0; i < 100; i++) {
+      tokens.add(link.generateToken())
+    }
+    expect(tokens.size).toBe(100)
+  })
+
+  it('tokens are 64 hex chars', () => {
+    const token = link.generateToken()
+    expect(token).toMatch(/^[0-9a-f]{64}$/)
+  })
+
+  it('reports listening after start', async () => {
+    await link.start()
+    expect(link.isListening).toBe(true)
+  })
+
+  it('accepts connection and performs registration handshake', async () => {
+    await link.start()
+    const { ws, token } = await connectAndRegister(port, 'test-web-container', {
+      url: 'http://localhost:3000',
+      capabilities: ['eval'],
+      meta: { name: 'test' },
+    })
+    openSockets.push(ws)
+
+    expect(token).toBeTruthy()
+    expect(link.connectionCount).toBe(1)
+
+    const connections = link.getConnections()
+    expect(connections).toHaveLength(1)
+    expect(connections[0].uuid).toBe('test-web-container')
+  })
+
+  it('rejects eval messages from web containers', async () => {
+    await link.start()
+    const { ws, token } = await connectAndRegister(port, 'attacker')
+    openSockets.push(ws)
+
+    const errorMsg = await new Promise<any>((resolve, reject) => {
+      ws.onmessage = (event: MessageEvent) => {
+        const msg = JSON.parse(event.data)
+        if (msg.type === 'error') resolve(msg)
+      }
+
+      ws.send(JSON.stringify(createTestMessage(MessageTypes.eval, {
+        code: 'process.exit(1)',
+        requestId: 'evil-123',
+      }, token)))
+
+      setTimeout(() => reject(new Error('Timeout')), 3000)
+    })
+
+    expect(errorMsg.type).toBe('error')
+    expect(errorMsg.data.message).toContain('not permitted')
+  })
+
+  it('eval sends code and resolves with result', async () => {
+    await link.start()
+    const { ws, token } = await connectAndRegister(port, 'eval-target')
+    openSockets.push(ws)
+
+    // Simulate web container responding to evals
+    ws.onmessage = (event: MessageEvent) => {
+      const msg = JSON.parse(event.data)
+      if (msg.type === 'eval') {
+        ws.send(JSON.stringify(createTestMessage(MessageTypes.evalResult, {
+          requestId: msg.data.requestId,
+          result: 42,
+        }, token)))
+      }
+    }
+
+    const result = await link.eval('eval-target', '21 * 2')
+    expect(result).toBe(42)
+  })
+
+  it('eval rejects when container not found', async () => {
+    await link.start()
+    await expect(link.eval('nonexistent', '1+1')).rejects.toThrow('No connection found')
+  })
+
+  it('eval rejects on timeout', async () => {
+    await link.start()
+    const { ws } = await connectAndRegister(port, 'slow-container')
+    openSockets.push(ws)
+
+    // Don't respond to eval — should timeout
+    await expect(link.eval('slow-container', '1+1', undefined, 200)).rejects.toThrow('timed out')
+  })
+
+  it('disconnect removes a specific client', async () => {
+    await link.start()
+    const { ws } = await connectAndRegister(port, 'to-disconnect')
+    openSockets.push(ws)
+
+    expect(link.connectionCount).toBe(1)
+    link.disconnect('to-disconnect', 'test')
+    await new Promise(r => setTimeout(r, 50))
+    expect(link.connectionCount).toBe(0)
+  })
+
+  it('emits connection and disconnection events', async () => {
+    await link.start()
+    const events: string[] = []
+    link.on('connection', (uuid: string) => events.push(`connect:${uuid}`))
+    link.on('disconnection', (uuid: string) => events.push(`disconnect:${uuid}`))
+
+    const { ws } = await connectAndRegister(port, 'event-test')
+
+    expect(events).toContain('connect:event-test')
+
+    await closeWs(ws)
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toContain('disconnect:event-test')
+  })
+
+  it('handles structured events from web containers', async () => {
+    await link.start()
+    const { ws, token } = await connectAndRegister(port, 'event-sender')
+    openSockets.push(ws)
+
+    const receivedEvent = new Promise<any>((resolve) => {
+      link.on('event', (uuid: string, eventName: string, data: any) => {
+        resolve({ uuid, eventName, data })
+      })
+    })
+
+    ws.send(JSON.stringify(createTestMessage(MessageTypes.event, {
+      eventName: 'userClick',
+      data: { x: 100, y: 200 },
+    }, token)))
+
+    const evt = await receivedEvent
+    expect(evt.uuid).toBe('event-sender')
+    expect(evt.eventName).toBe('userClick')
+    expect(evt.data).toEqual({ x: 100, y: 200 })
+  })
+
+  it('registration without uuid returns error', async () => {
+    await link.start()
+    const ws = new WebSocket(`ws://localhost:${port}`)
+    openSockets.push(ws)
+
+    const errorMsg = await new Promise<any>((resolve, reject) => {
+      ws.onopen = () => {
+        ws.send(JSON.stringify(createTestMessage(MessageTypes.register, {})))
+      }
+      ws.onmessage = (event: MessageEvent) => {
+        const msg = JSON.parse(event.data)
+        if (msg.type === 'error') resolve(msg)
+      }
+      ws.onerror = () => reject(new Error('WS error'))
+      setTimeout(() => reject(new Error('Timeout')), 3000)
+    })
+
+    expect(errorMsg.data.message).toContain('uuid')
+  })
+
+  it('stop cleans up server and connections', async () => {
+    await link.start()
+    const { ws } = await connectAndRegister(port, 'cleanup-test')
+    openSockets.push(ws)
+
+    await link.stop()
+    expect(link.isListening).toBe(false)
+    expect(link.connectionCount).toBe(0)
+  })
+})

package/test/conversation.test.ts

@@ -0,0 +1,220 @@
+import { describe, it, expect, beforeEach } from 'bun:test'
+import { AGIContainer } from '../src/agi/container.server'
+import type { Conversation } from '../src/agi/features/conversation'
+
+function makeConversation(opts: Record<string, any> = {}): Conversation {
+	const container = new AGIContainer()
+	return container.feature('conversation', { model: 'gpt-5', ...opts }) as Conversation
+}
+
+describe('Conversation', () => {
+	describe('state', () => {
+		it('initializes with empty messages when no history provided', () => {
+			const conv = makeConversation()
+			expect(conv.messages).toEqual([])
+		})
+
+		it('seeds message history from options', () => {
+			const history = [{ role: 'system', content: 'You are helpful.' }]
+			const conv = makeConversation({ history })
+			expect(conv.messages).toHaveLength(1)
+			expect(conv.messages[0]).toEqual(history[0])
+		})
+
+		it('uses provided model', () => {
+			const conv = makeConversation({ model: 'gpt-4.1' })
+			expect(conv.model).toBe('gpt-4.1')
+		})
+
+		it('isStreaming is false initially', () => {
+			const conv = makeConversation()
+			expect(conv.isStreaming).toBe(false)
+		})
+	})
+
+	describe('pushMessage', () => {
+		it('appends to messages', () => {
+			const conv = makeConversation()
+			conv.pushMessage({ role: 'user', content: 'hello' })
+			expect(conv.messages).toHaveLength(1)
+			expect(conv.messages[0]!.role).toBe('user')
+		})
+
+		it('does not mutate prior messages array', () => {
+			const conv = makeConversation()
+			const before = conv.messages
+			conv.pushMessage({ role: 'user', content: 'hi' })
+			expect(conv.messages).not.toBe(before)
+		})
+	})
+
+	describe('tools', () => {
+		it('starts with no tools', () => {
+			const conv = makeConversation()
+			expect(conv.availableTools).toHaveLength(0)
+		})
+
+		it('addTool registers a tool', () => {
+			const conv = makeConversation()
+			conv.addTool('greet', {
+				description: 'Says hello',
+				parameters: { type: 'object', properties: {} },
+				handler: async () => 'hello',
+			})
+			expect(conv.availableTools).toContain('greet')
+		})
+
+		it('removeTool deregisters a tool', () => {
+			const conv = makeConversation()
+			conv.addTool('greet', {
+				description: 'Says hello',
+				parameters: { type: 'object', properties: {} },
+				handler: async () => 'hello',
+			})
+			conv.removeTool('greet')
+			expect(conv.availableTools).not.toContain('greet')
+		})
+
+		it('updateTools merges without replacing unrelated tools', () => {
+			const conv = makeConversation()
+			conv.addTool('a', { description: 'A', parameters: { type: 'object', properties: {} }, handler: async () => 'a' })
+			conv.updateTools({ b: { description: 'B', parameters: { type: 'object', properties: {} }, handler: async () => 'b' } })
+			expect(conv.availableTools).toContain('a')
+			expect(conv.availableTools).toContain('b')
+		})
+
+		it('construction-time tools are available immediately', () => {
+			const conv = makeConversation({
+				tools: {
+					ping: { description: 'Ping', parameters: { type: 'object', properties: {} }, handler: async () => 'pong' }
+				}
+			})
+			expect(conv.availableTools).toContain('ping')
+		})
+	})
+
+	describe('estimateTokens', () => {
+		it('returns a near-zero baseline for empty messages', () => {
+			const conv = makeConversation()
+			expect(conv.estimateTokens()).toBeLessThan(10)
+		})
+
+		it('returns a positive number when messages exist', () => {
+			const conv = makeConversation({
+				history: [{ role: 'user', content: 'What is the capital of France?' }]
+			})
+			expect(conv.estimateTokens()).toBeGreaterThan(0)
+		})
+
+		it('increases as more messages are added', () => {
+			const conv = makeConversation()
+			conv.pushMessage({ role: 'user', content: 'Hello' })
+			const first = conv.estimateTokens()
+			conv.pushMessage({ role: 'assistant', content: 'Hi there, how can I help you today?' })
+			const second = conv.estimateTokens()
+			expect(second).toBeGreaterThan(first)
+		})
+	})
+
+	describe('stub()', () => {
+		it('exact string match returns the stub response', async () => {
+			const conv = makeConversation()
+			conv.stub('ping', 'pong')
+			const result = await conv.ask('ping')
+			expect(result).toBe('pong')
+		})
+
+		it('substring match triggers the stub', async () => {
+			const conv = makeConversation()
+			conv.stub('weather', 'Sunny and 72°F.')
+			const result = await conv.ask('what is the weather today?')
+			expect(result).toBe('Sunny and 72°F.')
+		})
+
+		it('regex match triggers the stub', async () => {
+			const conv = makeConversation()
+			conv.stub(/hello/i, 'Hey there!')
+			const result = await conv.ask('HELLO')
+			expect(result).toBe('Hey there!')
+		})
+
+		it('function response is called on each match', async () => {
+			const conv = makeConversation()
+			let callCount = 0
+			conv.stub('count', () => `call ${++callCount}`)
+			expect(await conv.ask('count')).toBe('call 1')
+			expect(await conv.ask('count')).toBe('call 2')
+		})
+
+		it('first matching stub wins', async () => {
+			const conv = makeConversation()
+			conv.stub('hello', 'first')
+			conv.stub('hello', 'second')
+			expect(await conv.ask('hello')).toBe('first')
+		})
+
+		it('appends user and assistant messages to history', async () => {
+			const conv = makeConversation()
+			conv.stub('hi', 'hello back')
+			await conv.ask('hi')
+			expect(conv.messages).toHaveLength(2)
+			expect(conv.messages[0]).toMatchObject({ role: 'user', content: 'hi' })
+			expect(conv.messages[1]).toMatchObject({ role: 'assistant', content: 'hello back' })
+		})
+
+		it('isStreaming is false after the call resolves', async () => {
+			const conv = makeConversation()
+			conv.stub('test', 'response')
+			await conv.ask('test')
+			expect(conv.isStreaming).toBe(false)
+		})
+
+		it('emits chunk events for each word', async () => {
+			const conv = makeConversation()
+			conv.stub('go', 'one two three')
+			const chunks: string[] = []
+			conv.on('chunk', (delta: string) => chunks.push(delta))
+			await conv.ask('go')
+			expect(chunks.join('')).toBe('one two three')
+		})
+
+		it('emits preview events with accumulating text', async () => {
+			const conv = makeConversation()
+			conv.stub('go', 'alpha beta')
+			const previews: string[] = []
+			conv.on('preview', (text: string) => previews.push(text))
+			await conv.ask('go')
+			expect(previews.at(-1)).toBe('alpha beta')
+			// Each preview should be longer than or equal to the previous
+			for (let i = 1; i < previews.length; i++) {
+				expect(previews[i]!.length).toBeGreaterThanOrEqual(previews[i - 1]!.length)
+			}
+		})
+
+		it('emits turnStart and turnEnd events', async () => {
+			const conv = makeConversation()
+			conv.stub('x', 'y')
+			const events: string[] = []
+			conv.on('turnStart', () => events.push('turnStart'))
+			conv.on('turnEnd', () => events.push('turnEnd'))
+			await conv.ask('x')
+			expect(events).toEqual(['turnStart', 'turnEnd'])
+		})
+
+		it('emits response event with the full text', async () => {
+			const conv = makeConversation()
+			conv.stub('question', 'the answer')
+			let emitted = ''
+			conv.on('response', (text: string) => { emitted = text })
+			await conv.ask('question')
+			expect(emitted).toBe('the answer')
+		})
+
+		it('stub is chainable', () => {
+			const conv = makeConversation()
+			const result = conv.stub('a', 'A').stub('b', 'B')
+			expect(result).toBe(conv)
+			expect(conv.availableTools).toHaveLength(0) // stubs don't affect tools
+		})
+	})
+})

package/test/features.test.ts

@@ -0,0 +1,160 @@
+import { NodeContainer } from '../src/node/container'
+
+describe('Features', () => {
+  describe('feature registry', () => {
+    it('has core features registered', () => {
+      const c = new NodeContainer()
+      const available = c.features.available
+      expect(available).toContain('fs')
+      expect(available).toContain('git')
+      expect(available).toContain('proc')
+      expect(available).toContain('os')
+      expect(available).toContain('networking')
+      expect(available).toContain('ui')
+      expect(available).toContain('vm')
+      expect(available).toContain('yaml')
+    })
+
+    it('features.has() works', () => {
+      const c = new NodeContainer()
+      expect(c.features.has('fs')).toBe(true)
+      expect(c.features.has('os')).toBe(true)
+      expect(c.features.has('totally_fake')).toBe(false)
+    })
+
+    it('features.lookup() returns a constructor', () => {
+      const c = new NodeContainer()
+      const FSClass = c.features.lookup('fs')
+      expect(typeof FSClass).toBe('function')
+    })
+  })
+
+  describe('core features are auto-enabled', () => {
+    it('has fs, git, proc, os, networking, ui, vm enabled', () => {
+      const c = new NodeContainer()
+      expect(c.enabledFeatureIds).toContain('fs')
+      expect(c.enabledFeatureIds).toContain('git')
+      expect(c.enabledFeatureIds).toContain('proc')
+      expect(c.enabledFeatureIds).toContain('os')
+      expect(c.enabledFeatureIds).toContain('networking')
+      expect(c.enabledFeatureIds).toContain('ui')
+      expect(c.enabledFeatureIds).toContain('vm')
+    })
+  })
+
+  describe('feature caching', () => {
+    it('same args return same instance', () => {
+      const c = new NodeContainer()
+      const a = c.feature('yaml')
+      const b = c.feature('yaml')
+      expect(a.uuid).toBe(b.uuid)
+    })
+
+    it('different containers return different instances', () => {
+      const c1 = new NodeContainer()
+      const c2 = new NodeContainer()
+      const a = c1.feature('yaml')
+      const b = c2.feature('yaml')
+      expect(a.uuid).not.toBe(b.uuid)
+    })
+  })
+
+  describe('feature instances', () => {
+    it('feature has a uuid', () => {
+      const c = new NodeContainer()
+      const yaml = c.feature('yaml')
+      expect(yaml.uuid).toBeDefined()
+      expect(typeof yaml.uuid).toBe('string')
+    })
+
+    it('feature has state', () => {
+      const c = new NodeContainer()
+      const yaml = c.feature('yaml')
+      expect(yaml.state).toBeDefined()
+      expect(typeof yaml.state.get).toBe('function')
+    })
+
+    it('feature has access to container', () => {
+      const c = new NodeContainer()
+      const yaml = c.feature('yaml')
+      expect(yaml.container.uuid).toBe(c.uuid)
+    })
+
+    it('feature has event bus', () => {
+      const c = new NodeContainer()
+      const yaml = c.feature('yaml')
+      expect(typeof yaml.on).toBe('function')
+      expect(typeof yaml.emit).toBe('function')
+    })
+  })
+
+  describe('OS feature', () => {
+    it('provides platform info', () => {
+      const c = new NodeContainer()
+      expect(c.os.platform).toBe(process.platform)
+    })
+
+    it('provides arch', () => {
+      const c = new NodeContainer()
+      expect(c.os.arch).toBe(process.arch)
+    })
+
+    it('provides homedir', () => {
+      const c = new NodeContainer()
+      expect(typeof c.os.homedir).toBe('string')
+      expect(c.os.homedir.length).toBeGreaterThan(0)
+    })
+
+    it('provides cpuCount', () => {
+      const c = new NodeContainer()
+      expect(c.os.cpuCount).toBeGreaterThan(0)
+    })
+
+    it('provides hostname', () => {
+      const c = new NodeContainer()
+      expect(typeof c.os.hostname).toBe('string')
+    })
+  })
+
+  describe('FS feature', () => {
+    it('can check if a path exists', () => {
+      const c = new NodeContainer()
+      expect(c.fs.exists(process.cwd())).toBe(true)
+      expect(c.fs.exists('/surely/this/does/not/exist_abc123')).toBe(false)
+    })
+  })
+
+  describe('VM feature', () => {
+    it('can run simple expressions', async () => {
+      const c = new NodeContainer()
+      const result = await c.vm.run('1 + 2 + 3')
+      expect(result).toBe(6)
+    })
+
+    it('can run code with context variables', async () => {
+      const c = new NodeContainer()
+      const result = await c.vm.run('x * y', { x: 6, y: 7 })
+      expect(result).toBe(42)
+    })
+  })
+
+  describe('Networking feature', () => {
+    it('can find an open port', async () => {
+      const c = new NodeContainer()
+      const port = await c.networking.findOpenPort(30000)
+      expect(port).toBeGreaterThanOrEqual(30000)
+    })
+  })
+
+  describe('YAML feature', () => {
+    it('can stringify and parse', () => {
+      const c = new NodeContainer()
+      const yaml = c.feature('yaml')
+      const data = { name: 'luca', version: 1 }
+      const str = yaml.stringify(data)
+      expect(typeof str).toBe('string')
+      const parsed = yaml.parse(str)
+      expect(parsed).toEqual(data)
+    })
+  })
+})