luca 3.0.0 → 3.0.2

package/test/container-link.test.ts

@@ -1,274 +0,0 @@
-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

@@ -1,220 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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)
-    })
-  })
-})