The all-in-one local AI studio for your desktop: chat, image and video generation and a coding agent in one free, open source app. Windows and Linux. No Docker, no terminal, no cloud required.
TypeScript agentai-chatai-studioall-in-onecoding-agentdesktop-appfluximage-generationlinuxllmlocal-ailocal-llmopen-sourceprivacyself-hostedstable-diffusionuncensoreduncensored-aivideo-generationwindows
import { afterEach, describe, expect, it } from 'vitest'
import type { StateStorage } from 'zustand/middleware'
import { REMOTE_STORE_KEY, connectionEverWorked, createRemoteClientStore, type RemoteClientStore, type RemoteClientStoreDeps } from '../remoteClientStore'
import { TOKEN_VAULT_KEY, createMemoryTokenVault, createStorageTokenVault } from '../tokenVault'
import { JWT_TTL_SECS, startFakeDesktop, type FakeDesktop } from './fakeDesktop'
/**
* Speicher, der sich wie IndexedDB verhaelt: jeder Zugriff ist asynchron. Der
* synchrone Ersatzweg von idbStorage in Node wuerde genau die Reihenfolge
* verstecken, um die es hier geht (Laden vor Schreiben, Schreiben vor Ende).
*/
function asyncMemoryStorage(initial: Record<string, string> = {}) {
const data = new Map<string, string>(Object.entries(initial))
let writes = 0
const storage: StateStorage = {
getItem: async (k) => {
await Promise.resolve()
return data.get(k) ?? null
},
setItem: async (k, v) => {
await Promise.resolve()
writes += 1
data.set(k, v)
},
removeItem: async (k) => {
await Promise.resolve()
data.delete(k)
},
}
return {
storage,
data,
get writes() {
return writes
},
snapshot: () => Object.fromEntries(data),
saved: () => JSON.parse(data.get(REMOTE_STORE_KEY) ?? 'null') as { state: Record<string, unknown> } | null,
}
}
let desktop: FakeDesktop | null = null
const opened: Array<() => void> = []
afterEach(async () => {
for (const off of opened.splice(0)) off()
await desktop?.stop()
desktop = null
})
async function open(deps: RemoteClientStoreDeps): Promise<RemoteClientStore> {
// Langes Sammelfenster: was in diesen Tests auf der Platte steht, steht dort,
// weil jemand flush() gerufen hat, nicht weil zufaellig 250 ms um waren.
const store = createRemoteClientStore({ autoResume: false, persistWaitMs: 60_000, ...deps })
await store.ready
return store
}
async function paired(deps: RemoteClientStoreDeps = {}) {
const mem = asyncMemoryStorage()
const store = await open({ storage: mem.storage, ...deps })
await store.useStore.getState().connect(desktop!.url, '123456')
expect(store.useStore.getState().status).toBe('connected')
return { store, mem, s: () => store.useStore.getState() }
}
function fakePage() {
const win = new EventTarget()
const doc = Object.assign(new EventTarget(), { visibilityState: 'visible' })
const ticks: Array<() => void> = []
const env = {
window: win as unknown as Window,
document: doc as unknown as Document,
setInterval: (fn: () => void) => ticks.push(fn),
clearInterval: () => {},
}
return {
env,
ticks,
pagehide: () => win.dispatchEvent(new Event('pagehide')),
hide: () => {
doc.visibilityState = 'hidden'
doc.dispatchEvent(new Event('visibilitychange'))
},
show: () => {
doc.visibilityState = 'visible'
doc.dispatchEvent(new Event('visibilitychange'))
},
}
}
describe('Verbindung', () => {
it('koppelt mit Adresse und Code und kennt danach Modelle, Rechte und Version', async () => {
desktop = await startFakeDesktop({ systemPrompt: 'Be brief.' })
const { s } = await paired()
expect(s().connection).toMatchObject({
baseUrl: desktop.url,
address: `127.0.0.1:${desktop.port}`,
route: 'loopback',
secure: false,
serverVersion: '3.0.5',
})
expect(s().connection?.pairedAt).toBeGreaterThan(0)
expect(s().models).toEqual(['qwen3:8b', 'gemma4:e4b'])
expect(s().hostConfig?.systemPrompt).toBe('Be brief.')
expect(s().permissions).toEqual({ filesystem: false, downloads: false, process_control: false, shell: false })
expect(s().error).toBeNull()
})
it('bleibt ohne Code bei "needs-code" stehen und meldet einen falschen Code lesbar', async () => {
desktop = await startFakeDesktop()
const mem = asyncMemoryStorage()
const store = await open({ storage: mem.storage })
const s = () => store.useStore.getState()
await s().connect(`${desktop.url}/mobile`)
expect(s().status).toBe('needs-code')
expect(s().error).toBeNull()
await s().submitCode('000000')
expect(s().status).toBe('needs-code')
expect(s().error).toMatchObject({ code: 'invalid-code' })
expect(s().token).toBe('')
await s().submitCode('123456')
expect(s().status).toBe('connected')
expect(s().error).toBeNull()
})
it('sperrt nach drei falschen Codes bis zum genannten Zeitpunkt und ruft den Desktop solange nicht an', async () => {
desktop = await startFakeDesktop()
let clock = 1_000_000
const store = await open({ storage: asyncMemoryStorage().storage, now: () => clock })
const s = () => store.useStore.getState()
await s().connect(desktop.url)
for (let i = 0; i < 3; i++) await s().submitCode('000000')
await s().submitCode('123456')
expect(s().error).toMatchObject({ code: 'rate-limited', retryAfterSeconds: 60 })
expect(s().retryAt).toBe(clock + 60_000)
const calls = desktop.log.length
await s().submitCode('123456')
expect(desktop.log.length).toBe(calls)
clock += 61_000
desktop.advance(61)
await s().submitCode('123456')
expect(s().status).toBe('connected')
expect(s().retryAt).toBeNull()
})
it('lehnt eine unlesbare Adresse ab, ohne ins Netz zu gehen', async () => {
const store = await open({ storage: asyncMemoryStorage().storage })
await store.useStore.getState().connect('123456')
expect(store.useStore.getState().status).toBe('unpaired')
expect(store.useStore.getState().error).toMatchObject({ code: 'invalid-address' })
})
it('verbindet sich durch einen zugestellten Link nicht von selbst', async () => {
desktop = await startFakeDesktop()
const store = await open({ storage: asyncMemoryStorage().storage })
const s = () => store.useStore.getState()
expect(s().offerLink(`lu://remote?url=${encodeURIComponent(desktop.url)}&code=123456`)).toBe(true)
expect(s().pendingLink).toMatchObject({ baseUrl: desktop.url, code: '123456', source: 'deep-link' })
expect(s().connection).toBeNull()
expect(desktop.log).toEqual([])
// Erst die Bestaetigung verbindet, dann aber gleich mit dem Code aus dem Link.
await s().connect(`lu://remote?url=${encodeURIComponent(desktop.url)}&code=123456`)
expect(s().status).toBe('connected')
expect(s().pendingLink).toBeNull()
expect(s().offerLink('not a link at all')).toBe(false)
})
it('meldet einen nicht erreichbaren Desktop als offline und findet ihn nicht fuer verbunden', async () => {
desktop = await startFakeDesktop()
const { s } = await paired()
await desktop.stop()
await s().verifyConnection()
expect(s().status).toBe('offline')
expect(s().error).toMatchObject({ code: 'unreachable' })
expect(s().error?.message).toMatch(/same Wi-Fi/)
// Das Token bleibt: der Desktop kann gleich wieder da sein.
expect(s().token).not.toBe('')
})
it('A17: nennt den Schritt, an dem die WLAN-Adresse nicht antwortet, und den naechsten Schritt', async () => {
desktop = await startFakeDesktop()
const s0 = await open({ storage: asyncMemoryStorage().storage })
await s0.useStore.getState().connect('http://127.0.0.1:9', '123456')
expect(s0.useStore.getState().error).toMatchObject({ code: 'unreachable' })
expect(s0.useStore.getState().error?.detail).toMatch(/^probe: GET \/remote-api\/status/)
expect(s0.useStore.getState().error?.message).toMatch(/matches the one under Remote Access/)
// Eine Hamachi-Adresse: der Satz sagt, welche Adresse gemeint ist.
const s3 = await open({ storage: asyncMemoryStorage().storage, fetch: async () => { throw new TypeError('Failed to fetch') } })
await s3.useStore.getState().connect('25.10.20.30', '123456')
expect(s3.useStore.getState().error?.message).toContain('usually 192.168.x.x')
// Die Kopplung gelingt, die Modelle kommen nicht: Schritt bootstrap, Aufruf /api/tags.
const failing: RemoteClientStoreDeps['fetch'] = async (url, init) => {
if (String(url).endsWith('/api/tags')) throw new TypeError('Failed to fetch')
return globalThis.fetch(url, init)
}
const s1 = await open({ storage: asyncMemoryStorage().storage, fetch: failing })
await s1.useStore.getState().connect(desktop.url, '123456')
const e1 = s1.useStore.getState().error
expect(e1?.detail).toMatch(/^bootstrap: GET \/api\/tags/)
expect(e1?.message).toMatch(/Pairing worked/)
// Der Code geht nicht durch: Schritt auth.
const noAuth: RemoteClientStoreDeps['fetch'] = async (url, init) => {
if (String(url).endsWith('/remote-api/auth')) throw new TypeError('Failed to fetch')
return globalThis.fetch(url, init)
}
const s2 = await open({ storage: asyncMemoryStorage().storage, fetch: noAuth })
await s2.useStore.getState().connect(desktop.url, '123456')
expect(s2.useStore.getState().error?.detail).toMatch(/^auth: POST \/remote-api\/auth/)
expect(s2.useStore.getState().error?.message).toMatch(/pairing window/)
})
it('faellt auf "needs-code" zurueck, wenn die Sitzung am Desktop abgelaufen ist', async () => {
desktop = await startFakeDesktop()
const { s } = await paired()
desktop.advance(JWT_TTL_SECS + 1)
await s().verifyConnection()
expect(s().status).toBe('needs-code')
expect(s().error).toMatchObject({ code: 'session-expired' })
expect(s().token).toBe('')
})
it('zeigt die Sperre des Desktops als eigenen Zustand', async () => {
desktop = await startFakeDesktop()
const { s } = await paired()
desktop.revokeMemory()
await s().verifyConnection()
expect(s().status).toBe('blocked')
expect(s().error).toMatchObject({ code: 'memory-revoked' })
})
it('meldet sich beim Trennen am Desktop ab und behaelt Adresse und Chats', async () => {
desktop = await startFakeDesktop()
const { s } = await paired()
await s().sendMessage('hi')
await s().disconnect()
expect(desktop.devices).toEqual([])
expect(s().status).toBe('needs-code')
expect(s().token).toBe('')
expect(s().connection?.baseUrl).toBe(desktop.url)
expect(s().chats[0].messages).toHaveLength(2)
await s().forget()
expect(s().status).toBe('unpaired')
expect(s().connection).toBeNull()
expect(s().chats).toHaveLength(1)
})
it('wirft das Token weg, wenn eine andere Adresse eingetragen wird', async () => {
desktop = await startFakeDesktop()
const other = await startFakeDesktop({ passcode: '222222' })
try {
const { s } = await paired()
const first = s().token
await s().connect(other.url)
expect(s().status).toBe('needs-code')
expect(s().token).toBe('')
// Der zweite Desktop hat das Token des ersten nie gesehen.
expect(other.log).toEqual(['GET /remote-api/status'])
expect(first).not.toBe('')
} finally {
await other.stop()
}
})
})
describe('Chat', () => {
it('sendet, zeigt die Antwort, vergibt einen Titel und spiegelt beide Nachrichten an den Desktop', async () => {
desktop = await startFakeDesktop({ reply: 'Sure thing.', systemPrompt: 'Be brief.' })
const { s } = await paired()
expect(await s().sendMessage(' Tell me about the weather in Hamburg today please ')).toBe('sent')
const chat = s().chats[0]
expect(chat.title).toBe('Tell me about the weather in Ham')
expect(chat.model).toBe('qwen3:8b')
expect(chat.messages.map((m) => [m.role, m.content, m.state])).toEqual([
['user', 'Tell me about the weather in Hamburg today please', 'done'],
['assistant', 'Sure thing.', 'done'],
])
expect(s().streamingChatId).toBeNull()
expect(desktop.chatRequests[0].body.messages).toEqual([
{ role: 'system', content: 'Be brief.' },
{ role: 'user', content: 'Tell me about the weather in Hamburg today please' },
])
await expect.poll(() => desktop!.chatEvents.map((e) => e.role)).toEqual(['user', 'assistant'])
expect(desktop.chatEvents[1]).toMatchObject({ content: 'Sure thing.', chat_id: chat.id, mode: 'lu' })
})
it('nimmt den Entwurf, wenn kein Text uebergeben wird, und leert ihn erst nach dem Senden', async () => {
desktop = await startFakeDesktop()
const { s } = await paired()
const id = s().newChat()
s().setDraft(id, 'from the draft')
expect(await s().sendMessage()).toBe('sent')
expect(s().chats[0].messages[0].content).toBe('from the draft')
expect(s().drafts[id]).toBeUndefined()
expect(await s().sendMessage()).toBe('empty')
})
it('sendet nicht ohne Verbindung und nicht doppelt', async () => {
desktop = await startFakeDesktop({ delayMs: 80 })
const store = await open({ storage: asyncMemoryStorage().storage })
expect(await store.useStore.getState().sendMessage('hi')).toBe('not-connected')
const { s } = await paired()
const first = s().sendMessage('one')
expect(await s().sendMessage('two')).toBe('busy')
await first
expect(s().chats[0].messages.filter((m) => m.role === 'user')).toHaveLength(1)
})
it('haelt beim Stoppen den Teilstand als "stopped" fest', async () => {
desktop = await startFakeDesktop({ reply: 'a b c d e f g h i j k l', delivery: 'chunked', delayMs: 15 })
const { s } = await paired()
const sending = s().sendMessage('go')
await expect.poll(() => s().chats[0]?.messages[1]?.content.length ?? 0).toBeGreaterThan(3)
s().stopStreaming()
expect(s().streamingChatId).toBeNull()
await sending
const reply = s().chats[0].messages[1]
expect(reply.state).toBe('stopped')
expect(reply.content.length).toBeGreaterThan(3)
expect(reply.content.length).toBeLessThan(23)
})
it('markiert die Antwort als gescheitert, wenn das Token beim Senden abgelaufen ist, und holt sie nach dem Koppeln nach', async () => {
desktop = await startFakeDesktop({ reply: 'Back again.' })
const { s } = await paired()
desktop.advance(JWT_TTL_SECS + 1)
await s().sendMessage('are you there')
expect(s().status).toBe('needs-code')
expect(s().chats[0].messages[1]).toMatchObject({ state: 'failed', content: '', error: { code: 'session-expired' } })
expect(await s().retryLast()).toBe('not-connected')
// Nach einer Stunde zeigt der Desktop laengst einen neuen Code.
await s().submitCode(desktop.shownPasscode())
expect(s().status).toBe('connected')
expect(await s().retryLast()).toBe('sent')
expect(s().chats[0].messages.map((m) => [m.role, m.content, m.state])).toEqual([
['user', 'are you there', 'done'],
['assistant', 'Back again.', 'done'],
])
// Die Nachricht des Nutzers wurde nur einmal an den Desktop gespiegelt.
await expect.poll(() => desktop!.chatEvents.filter((e) => e.role === 'user')).toHaveLength(1)
})
it('meldet einen verschwundenen Desktop am Chat und im Verbindungszustand', async () => {
desktop = await startFakeDesktop()
const { s } = await paired()
await desktop.stop()
await s().sendMessage('hello?')
expect(s().status).toBe('offline')
expect(s().chats[0].messages[1]).toMatchObject({ state: 'failed', error: { code: 'unreachable' } })
expect(s().streamingChatId).toBeNull()
})
it('behaelt bei einem Abriss mitten in der Antwort, was schon da war', async () => {
desktop = await startFakeDesktop({ reply: 'one two three four five', delivery: 'chunked', delayMs: 5 })
desktop.killStreamAfterLines = 2
const { s } = await paired()
await s().sendMessage('count')
expect(s().chats[0].messages[1]).toMatchObject({
state: 'interrupted',
content: 'one two ',
error: { code: 'connection-lost' },
})
// Der Desktop ist noch da: die angestossene Pruefung laesst die Verbindung stehen.
await expect.poll(() => s().status).toBe('connected')
expect(await s().retryLast()).toBe('sent')
expect(s().chats[0].messages[1]).toMatchObject({ state: 'done', content: 'one two three four five' })
// Die unvollstaendige Antwort wurde ersetzt, nicht als Verlauf mitgeschickt.
expect(desktop.chatRequests.at(-1)?.body.messages).toEqual([{ role: 'user', content: 'count' }])
})
it('laesst einen Backend-Fehler am Chat stehen, ohne die Verbindung zu verwerfen', async () => {
desktop = await startFakeDesktop()
const { s } = await paired()
desktop.backendDown = true
await s().sendMessage('hi')
expect(s().status).toBe('connected')
expect(s().chats[0].messages[1]).toMatchObject({ state: 'failed', error: { code: 'backend', status: 502 } })
})
it('schickt den eigenen Systemprompt eines Chats statt dem des Desktops', async () => {
desktop = await startFakeDesktop({ systemPrompt: 'From the desktop.' })
const { s } = await paired()
const id = s().newChat()
s().setSystemPrompt(id, 'You are a pirate.')
s().setThinkEnabled(id, true)
await s().sendMessage('ahoy')
expect(desktop.chatRequests[0].body).toMatchObject({
think: true,
messages: [
{ role: 'system', content: 'You are a pirate.' },
{ role: 'user', content: 'ahoy' },
],
})
})
})
describe('Neu erzeugen und Bearbeiten', () => {
it('verwirft eine Antwort samt allem danach und stellt die Frage davor erneut, ohne sie doppelt zu spiegeln', async () => {
desktop = await startFakeDesktop({ reply: 'First answer.' })
const { s } = await paired()
await s().sendMessage('one')
await s().sendMessage('two')
const chat = s().chats[0]
expect(chat.messages).toHaveLength(4)
await expect.poll(() => desktop!.chatEvents.filter((e) => e.role === 'user')).toHaveLength(2)
desktop.reply = 'Second try.'
expect(await s().regenerate(chat.id, chat.messages[1].id)).toBe('sent')
expect(s().chats[0].messages.map((m) => [m.role, m.content, m.state])).toEqual([
['user', 'one', 'done'],
['assistant', 'Second try.', 'done'],
])
// Der Desktop bekam nur die Frage, nicht die verworfene Antwort.
expect(desktop.chatRequests.at(-1)?.body.messages).toEqual([{ role: 'user', content: 'one' }])
// Die Frage stand schon im Desktop-Chat.
await expect.poll(() => desktop!.chatEvents.filter((e) => e.role === 'assistant').at(-1)?.content).toBe('Second try.')
expect(desktop.chatEvents.filter((e) => e.role === 'user')).toHaveLength(2)
})
it('aendert eine eigene Nachricht, verwirft alles danach und spiegelt die neue Frage', async () => {
desktop = await startFakeDesktop({ reply: 'Answer.' })
const { s } = await paired()
await s().sendMessage('helo')
await s().sendMessage('more')
const chat = s().chats[0]
await expect.poll(() => desktop!.chatEvents.filter((e) => e.role === 'user')).toHaveLength(2)
expect(await s().editAndResend(chat.id, chat.messages[0].id, ' hello ')).toBe('sent')
expect(s().chats[0].messages.map((m) => [m.role, m.content])).toEqual([
['user', 'hello'],
['assistant', 'Answer.'],
])
expect(s().chats[0].messages[0].id).toBe(chat.messages[0].id)
expect(desktop.chatRequests.at(-1)?.body.messages).toEqual([{ role: 'user', content: 'hello' }])
await expect.poll(() => desktop!.chatEvents.filter((e) => e.role === 'user').map((e) => e.content)).toEqual(['helo', 'more', 'hello'])
})
it('laesst den Verlauf stehen, wenn es nicht geht: falsche Nachricht, leerer Text, laufende Antwort, getrennt', async () => {
desktop = await startFakeDesktop({ reply: 'Answer.' })
const { s } = await paired()
await s().sendMessage('one')
const chat = s().chats[0]
const [asked, answer] = chat.messages
expect(await s().regenerate(chat.id, asked.id)).toBe('empty')
expect(await s().editAndResend(chat.id, answer.id, 'x')).toBe('empty')
expect(await s().editAndResend(chat.id, asked.id, ' ')).toBe('empty')
expect(await s().regenerate(chat.id, 'nope')).toBe('empty')
expect(await s().regenerate('nope', answer.id)).toBe('no-chat')
expect(s().chats[0].messages).toEqual(chat.messages)
desktop.delayMs = 300
const sending = s().sendMessage('two')
await expect.poll(() => s().streamingChatId).toBe(chat.id)
expect(await s().regenerate(chat.id, answer.id)).toBe('busy')
expect(await s().editAndResend(chat.id, asked.id, 'changed')).toBe('busy')
await sending
expect(s().chats[0].messages).toHaveLength(4)
await desktop.stop()
await s().verifyConnection()
expect(await s().regenerate(chat.id, answer.id)).toBe('not-connected')
expect(s().chats[0].messages).toHaveLength(4)
})
})
describe('Persistenz', () => {
it('uebersteht einen Neustart: Adresse, Chats, aktiver Chat und Entwurf sind wieder da, die Sitzung auch', async () => {
desktop = await startFakeDesktop({ reply: 'Stored answer.' })
const mem = asyncMemoryStorage()
const first = await open({ storage: mem.storage })
const a = () => first.useStore.getState()
await a().connect(desktop.url, '123456')
await a().sendMessage('remember me')
const chatId = a().activeChatId
a().setDraft(chatId, 'half a thought')
await first.flush()
const second = createRemoteClientStore({ storage: mem.storage, persistWaitMs: 60_000 })
expect(second.useStore.getState().hydrated).toBe(false)
await second.ready
const b = () => second.useStore.getState()
expect(b().hydrated).toBe(true)
expect(b().connection?.baseUrl).toBe(desktop.url)
expect(b().activeChatId).toBe(chatId)
expect(b().drafts[chatId]).toBe('half a thought')
expect(b().chats[0].messages.map((m) => m.content)).toEqual(['remember me', 'Stored answer.'])
// autoResume: mit dem Token aus der Ablage geht es ohne neuen Code weiter.
await expect.poll(() => b().status).toBe('connected')
expect(b().models).toEqual(['qwen3:8b', 'gemma4:e4b'])
})
// Gegenpruefung iPhone, Runde 22, N10: ein Verbindungsversuch, der in "took too long to answer" endete,
// stand danach als Desktop in den Einstellungen.
describe('gemerkt wird nur ein Desktop, der je funktioniert hat', () => {
it('die Regel: einmal gekoppelt oder einmal mit Sitzung erreicht', () => {
expect(connectionEverWorked(null)).toBe(false)
expect(connectionEverWorked(undefined)).toBe(false)
expect(connectionEverWorked({ pairedAt: null, lastOkAt: null })).toBe(false)
expect(connectionEverWorked({ pairedAt: 0, lastOkAt: 0 })).toBe(false)
expect(connectionEverWorked({ pairedAt: Number.NaN, lastOkAt: null })).toBe(false)
expect(connectionEverWorked({ pairedAt: 1_700_000_000_000, lastOkAt: null })).toBe(true)
expect(connectionEverWorked({ pairedAt: null, lastOkAt: 1_700_000_000_000 })).toBe(true)
})
it('ein gescheiterter Versuch bleibt fuer die laufende Seite im Speicher und kommt nie auf die Platte', async () => {
const mem = asyncMemoryStorage()
const store = await open({ storage: mem.storage })
const s = () => store.useStore.getState()
// An dieser Adresse hoert niemand.
await s().connect('http://127.0.0.1:9', '123456')
expect(s().status).toBe('offline')
// Die Seite des Versuchs braucht Adresse und Fehler weiter ("Try again", die Liste der Gruende).
expect(s().connection?.baseUrl).toBe('http://127.0.0.1:9')
expect(s().error).not.toBeNull()
await store.flush()
expect(mem.saved()?.state.connection ?? null).toBeNull()
// Nach dem Neustart gibt es keinen Desktop.
const second = createRemoteClientStore({ storage: mem.storage, persistWaitMs: 60_000, autoResume: false })
await second.ready
expect(second.useStore.getState().connection).toBeNull()
expect(second.useStore.getState().status).toBe('unpaired')
})
it('ein Desktop, der antwortet und auf den Code wartet, ist noch nicht gemerkt; mit dem Code ist er es', async () => {
desktop = await startFakeDesktop()
const mem = asyncMemoryStorage()
const store = await open({ storage: mem.storage })
const s = () => store.useStore.getState()
await s().connect(desktop.url)
expect(s().status).toBe('needs-code')
await store.flush()
expect(mem.saved()?.state.connection ?? null).toBeNull()
await s().submitCode('123456')
expect(s().status).toBe('connected')
await store.flush()
expect((mem.saved()!.state.connection as { baseUrl: string }).baseUrl).toBe(desktop.url)
})
it('ein falscher Code merkt nichts', async () => {
desktop = await startFakeDesktop()
const mem = asyncMemoryStorage()
const store = await open({ storage: mem.storage })
await store.useStore.getState().connect(desktop.url, '000000')
expect(store.useStore.getState().status).toBe('needs-code')
await store.flush()
expect(mem.saved()?.state.connection ?? null).toBeNull()
})
it('ein Fehleintrag einer aelteren Version wird beim Start nicht geladen, ein echter Desktop schon', async () => {
const wrong = { baseUrl: 'http://192.168.178.20:11435', address: '192.168.178.20:11435', route: 'lan', secure: false, pairedAt: null, lastOkAt: null, serverVersion: '', hostName: '' }
const memWrong = asyncMemoryStorage({ [REMOTE_STORE_KEY]: JSON.stringify({ state: { connection: wrong, chats: [], activeChatId: '', drafts: {} }, version: 1 }) })
const first = createRemoteClientStore({ storage: memWrong.storage, persistWaitMs: 60_000, autoResume: false })
await first.ready
expect(first.useStore.getState().connection).toBeNull()
expect(first.useStore.getState().status).toBe('unpaired')
const real = { ...wrong, pairedAt: 1_700_000_000_000, lastOkAt: 1_700_000_100_000 }
const memReal = asyncMemoryStorage({ [REMOTE_STORE_KEY]: JSON.stringify({ state: { connection: real, chats: [], activeChatId: '', drafts: {} }, version: 1 }) })
const second = createRemoteClientStore({ storage: memReal.storage, persistWaitMs: 60_000, autoResume: false })
await second.ready
expect(second.useStore.getState().connection?.address).toBe('192.168.178.20:11435')
// Ohne Token in der Ablage fragt er nach dem Code, statt den Desktop zu vergessen.
expect(second.useStore.getState().status).toBe('needs-code')
})
it('ein gekoppelter Desktop, der gerade nicht antwortet, bleibt gemerkt', async () => {
desktop = await startFakeDesktop()
const { store, mem, s } = await paired()
await desktop.stop()
desktop = null
await s().verifyConnection()
expect(s().status).toBe('offline')
await store.flush()
expect(mem.saved()!.state.connection).not.toBeNull()
})
})
it('schreibt das Token nie in den Zustand, sondern getrennt in die Ablage', async () => {
desktop = await startFakeDesktop()
const { store, mem, s } = await paired()
await s().sendMessage('hi')
await store.flush()
const token = s().token
expect(token.length).toBeGreaterThan(10)
const blob = mem.data.get(REMOTE_STORE_KEY) ?? ''
expect(blob).toContain('"chats"')
expect(blob).not.toContain(token)
expect(Object.keys(mem.saved()!.state).sort()).toEqual(['activeChatId', 'chats', 'connection', 'drafts'])
expect(JSON.parse(mem.data.get(TOKEN_VAULT_KEY) ?? '{}')).toMatchObject({ baseUrl: desktop.url, token })
})
it('kann mit einer anderen Ablage arbeiten, ohne dass der Store es merkt', async () => {
desktop = await startFakeDesktop()
const mem = asyncMemoryStorage()
const vault = createMemoryTokenVault()
const first = await open({ storage: mem.storage, vault })
await first.useStore.getState().connect(desktop.url, '123456')
await first.flush()
expect(mem.data.has(TOKEN_VAULT_KEY)).toBe(false)
expect(await vault.load(desktop.url)).toBe(first.useStore.getState().token)
expect(await vault.load('http://192.168.1.99:11435')).toBeNull()
const second = await open({ storage: mem.storage, vault })
expect(second.useStore.getState().token).toBe(first.useStore.getState().token)
})
it('gibt ein Token nur fuer die Adresse heraus, fuer die es gespeichert wurde', async () => {
const mem = asyncMemoryStorage()
const vault = createStorageTokenVault(mem.storage)
await vault.save('http://192.168.1.20:11435', 'secret-token')
expect(await vault.load('http://192.168.1.20:11435')).toBe('secret-token')
expect(await vault.load('http://192.168.1.21:11435')).toBeNull()
await vault.clear()
expect(await vault.load('http://192.168.1.20:11435')).toBeNull()
mem.data.set(TOKEN_VAULT_KEY, 'not json')
expect(await vault.load('http://192.168.1.20:11435')).toBeNull()
})
it('ueberschreibt gespeicherte Chats nicht mit dem leeren Anfangszustand, wenn vor dem Laden etwas passiert', async () => {
desktop = await startFakeDesktop()
const mem = asyncMemoryStorage()
const first = await open({ storage: mem.storage })
await first.useStore.getState().connect(desktop.url, '123456')
await first.useStore.getState().sendMessage('keep me')
await first.flush()
const before = mem.data.get(REMOTE_STORE_KEY)
const second = createRemoteClientStore({ storage: mem.storage, autoResume: false, persistWaitMs: 0 })
// Noch nicht geladen: diese Aenderung trifft den leeren Anfangszustand.
second.useStore.getState().setDraft('', 'typed too early')
await second.flush()
expect(mem.data.get(REMOTE_STORE_KEY)).toBe(before)
await second.ready
expect(second.useStore.getState().chats[0].messages[0].content).toBe('keep me')
})
it('schreibt bei pagehide und beim Verstecken sofort, ohne das Sammelfenster abzuwarten', async () => {
desktop = await startFakeDesktop()
const { store, mem, s } = await paired()
const page = fakePage()
opened.push(store.attachLifecycle(page.env))
await store.flush()
s().setDraft('', 'draft before pagehide')
expect(mem.saved()?.state.drafts).toEqual({})
page.pagehide()
await expect.poll(() => mem.saved()?.state.drafts).toEqual({ '': 'draft before pagehide' })
s().setDraft('', 'draft before hiding')
page.hide()
await expect.poll(() => mem.saved()?.state.drafts).toEqual({ '': 'draft before hiding' })
})
it('nimmt nach dem Abmelden der Ereignisse nichts mehr an', async () => {
desktop = await startFakeDesktop()
const { store, mem, s } = await paired()
const page = fakePage()
const off = store.attachLifecycle(page.env)
await store.flush()
off()
s().setDraft('', 'nobody flushes this')
page.pagehide()
await new Promise((r) => setTimeout(r, 20))
expect(mem.saved()?.state.drafts).toEqual({})
})
})
describe('App im Hintergrund', () => {
it('beendet den laufenden Chat sauber, speichert den Teilstand und prueft bei der Rueckkehr die Verbindung', async () => {
desktop = await startFakeDesktop({ reply: 'a b c d e f g h i j k l m n', delivery: 'chunked', delayMs: 15 })
const { store, mem, s } = await paired()
const page = fakePage()
opened.push(store.attachLifecycle(page.env))
const sending = s().sendMessage('long answer please')
await expect.poll(() => s().chats[0]?.messages[1]?.content.length ?? 0).toBeGreaterThan(3)
page.hide()
// Sofort, im selben Atemzug: danach darf das System die App einfrieren.
expect(s().streamingChatId).toBeNull()
const partial = s().chats[0].messages[1]
expect(partial.state).toBe('interrupted')
expect(partial.content.length).toBeGreaterThan(3)
await expect.poll(() => {
const chats = mem.saved()?.state.chats as Array<{ messages: Array<{ state: string; content: string }> }> | undefined
return chats?.[0]?.messages[1]
}).toMatchObject({ state: 'interrupted', content: partial.content })
await expect.poll(() => desktop!.chatRequests[0].clientGone).toBe(true)
await sending
// Der abgewickelte Lauf hat den gespeicherten Teilstand nicht mehr angefasst.
expect(s().chats[0].messages[1]).toEqual(partial)
const before = desktop.log.filter((l) => l === 'GET /remote-api/status').length
page.show()
await expect.poll(() => desktop!.log.filter((l) => l === 'GET /remote-api/status').length).toBe(before + 1)
await expect.poll(() => s().status).toBe('connected')
desktop.delivery = 'buffered'
desktop.delayMs = 0
expect(await s().retryLast()).toBe('sent')
expect(s().chats[0].messages.map((m) => [m.role, m.state])).toEqual([
['user', 'done'],
['assistant', 'done'],
])
expect(s().chats[0].messages[1].content).toBe('a b c d e f g h i j k l m n')
})
it('bricht auch ab, wenn der Desktop noch sammelt, und laesst eine leere, wiederholbare Antwort zurueck', async () => {
desktop = await startFakeDesktop({ delayMs: 2_000 })
const { s } = await paired()
const sending = s().sendMessage('hi')
await expect.poll(() => desktop!.chatRequests.length).toBe(1)
await s().handleBackground()
expect(s().chats[0].messages[1]).toMatchObject({ state: 'interrupted', content: '' })
await sending
await expect.poll(() => desktop!.chatRequests[0].clientGone).toBe(true)
})
it('findet nach einem Abschuss durch das System keine ewig laufende Antwort vor', async () => {
desktop = await startFakeDesktop({ reply: 'a b c d e f g h', delivery: 'chunked', delayMs: 20 })
const { store, mem, s } = await paired()
const sending = s().sendMessage('go')
await expect.poll(() => s().chats[0]?.messages[1]?.content.length ?? 0).toBeGreaterThan(1)
// Der Zwischenstand landet auf der Platte, dann ist der Prozess weg.
await store.flush()
const disk = mem.snapshot()
const onDisk = JSON.parse(disk[REMOTE_STORE_KEY]) as { state: { chats: Array<{ messages: Array<{ state: string }> }> } }
expect(onDisk.state.chats[0].messages[1].state).toBe('pending')
const reborn = await open({ storage: asyncMemoryStorage(disk).storage })
const reply = reborn.useStore.getState().chats[0].messages[1]
expect(reply.state).toBe('interrupted')
expect(reply.content.length).toBeGreaterThan(1)
expect(reborn.useStore.getState().streamingChatId).toBeNull()
s().stopStreaming()
await sending
})
it('prueft bei der Rueckkehr und merkt, wenn die Sitzung inzwischen abgelaufen ist', async () => {
desktop = await startFakeDesktop()
const { store, s } = await paired()
const page = fakePage()
opened.push(store.attachLifecycle(page.env))
page.hide()
desktop.advance(JWT_TTL_SECS + 1)
page.show()
await expect.poll(() => s().status).toBe('needs-code')
expect(s().error).toMatchObject({ code: 'session-expired' })
})
it('haelt die Sitzung mit dem Lebenszeichen am Leben und legt das neue Token in die Ablage', async () => {
desktop = await startFakeDesktop()
const vault = createMemoryTokenVault()
const { store, s } = await paired({ vault })
const page = fakePage()
opened.push(store.attachLifecycle(page.env))
const first = s().token
for (let i = 0; i < 9; i++) {
desktop.advance(10 * 60)
page.ticks[0]()
await expect.poll(() => desktop!.log.filter((l) => l === 'GET /remote-api/status/full').length).toBe(i + 2)
}
// 90 Minuten spaeter, weit hinter der Lebensdauer des ersten Tokens.
await s().verifyConnection()
expect(s().status).toBe('connected')
expect(s().token).not.toBe(first)
await expect.poll(() => vault.load(desktop!.url)).toBe(s().token)
})
it('schickt kein Lebenszeichen, solange die App nicht sichtbar ist', async () => {
desktop = await startFakeDesktop()
const { store } = await paired()
const page = fakePage()
opened.push(store.attachLifecycle(page.env))
page.hide()
const calls = desktop.log.length
page.ticks[0]()
await new Promise((r) => setTimeout(r, 20))
expect(desktop.log.length).toBe(calls)
})
})
describe('Runde 2: Agentenmodus', () => {
it('laesst das Modell ein Werkzeug am Desktop benutzen und haelt den Schritt an der Antwort fest', async () => {
desktop = await startFakeDesktop({ reply: 'The note says: file body.', systemPrompt: 'Be brief.' })
const { s } = await paired()
// Der Schalter wird NACH dem Koppeln eingeschaltet: der Lauf fragt den Stand frisch ab.
desktop.permissions.filesystem = true
const chatId = s().newChat()
s().setAgentMode(chatId, true)
desktop.nextToolCalls = [{ function: { name: 'file_read', arguments: { path: 'note.txt' } } }]
expect(await s().sendMessage('Read note.txt')).toBe('sent')
const answer = s().chats[0].messages[1]
expect(answer).toMatchObject({ role: 'assistant', state: 'done', content: 'The note says: file body.' })
expect(answer.steps).toHaveLength(1)
expect(answer.steps![0]).toMatchObject({ tool: 'file_read', state: 'done' })
expect(s().permissions?.filesystem).toBe(true)
expect(desktop.toolCalls[0]).toMatchObject({ tool: 'file_read', chatId })
const first = desktop.chatRequests[0].body
const names = (first.tools as Array<{ function: { name: string } }>).map((t) => t.function.name)
expect(names).toContain('file_read')
expect(names).not.toContain('shell_execute')
const system = (first.messages as Array<{ role: string; content: string }>)[0]
expect(system.role).toBe('system')
expect(system.content).toContain('autonomous AI agent')
// Im Agentenmodus faehrt der Prompt des Desktops nicht mit, wie auf der Webseite.
expect(system.content).not.toContain('Be brief.')
await expect.poll(() => desktop!.chatEvents.map((e) => e.role)).toEqual(['user', 'assistant'])
})
it('sagt lesbar, wenn das Modell keine Werkzeuge kann, und laesst die Verbindung stehen', async () => {
desktop = await startFakeDesktop({ models: ['notools:1b'] })
const { s } = await paired()
const chatId = s().newChat()
s().setAgentMode(chatId, true)
expect(await s().sendMessage('Hi')).toBe('sent')
const answer = s().chats[0].messages[1]
expect(answer.state).toBe('failed')
expect(answer.error?.code).toBe('tools-unsupported')
expect(answer.error?.message).toContain('Agent mode')
expect(s().status).toBe('connected')
})
it('schickt ohne Agentenmodus keine Werkzeuge mit', async () => {
desktop = await startFakeDesktop()
const { s } = await paired()
await s().sendMessage('Hi')
expect(desktop.chatRequests[0].body.tools).toBeUndefined()
expect(s().chats[0].messages[1].steps).toBeUndefined()
})
it('setzt die Sprechweise in den Systemprompt und vor jede Nutzernachricht', async () => {
desktop = await startFakeDesktop()
const { s } = await paired()
const chatId = s().newChat()
s().setCaveman(chatId, 'full')
await s().sendMessage('Explain DNS')
const sent = desktop.chatRequests[0].body.messages as Array<{ role: string; content: string }>
expect(sent[0].role).toBe('system')
expect(sent[1].content.endsWith('\nExplain DNS')).toBe(true)
expect(sent[1].content.length).toBeGreaterThan('Explain DNS'.length + 5)
// Im Verlauf am Handy steht, was der Mensch getippt hat.
expect(s().chats[0].messages[0].content).toBe('Explain DNS')
s().setCaveman(chatId, 'nonsense' as never)
expect(s().chats[0].caveman).toBe('off')
})
})
describe('Runde 2: Bilder', () => {
const photo = { mimeType: 'image/jpeg', thumb: 'dGh1bWI=', data: 'ZnVsbGltYWdl', name: 'cat.jpg' }
it('schickt die Bilddaten an das Modell und speichert nur das Vorschaubild', async () => {
desktop = await startFakeDesktop({ reply: 'A cat.' })
const { s, store, mem } = await paired()
expect(await s().sendMessage('What is this?', { images: [photo] })).toBe('sent')
const sent = desktop.chatRequests[0].body.messages as Array<{ role: string; content: string; images?: string[] }>
expect(sent.at(-1)).toEqual({ role: 'user', content: 'What is this?', images: ['ZnVsbGltYWdl'] })
expect(s().chats[0].messages[0].images).toEqual([{ mimeType: 'image/jpeg', thumb: 'dGh1bWI=', name: 'cat.jpg' }])
await store.flush()
const raw = mem.data.get(REMOTE_STORE_KEY) ?? ''
expect(raw).toContain('dGh1bWI=')
expect(raw).not.toContain('ZnVsbGltYWdl')
})
it('sendet ein Bild auch ohne Text und nennt den Chat dann "Photo"', async () => {
desktop = await startFakeDesktop()
const { s } = await paired()
expect(await s().sendMessage('', { images: [photo] })).toBe('sent')
expect(s().chats[0].title).toBe('Photo')
expect(await s().sendMessage(' ')).toBe('empty')
})
it('nimmt hoechstens vier Bilder und keins ohne Daten', async () => {
desktop = await startFakeDesktop()
const { s } = await paired()
const many = Array.from({ length: 6 }, (_, i) => ({ ...photo, data: `ZGF0YQ${i}` }))
await s().sendMessage('Look', { images: [{ ...photo, data: '' }, ...many] })
expect(s().chats[0].messages[0].images).toHaveLength(4)
const sent = desktop.chatRequests[0].body.messages as Array<{ images?: string[] }>
expect(sent.at(-1)?.images).toHaveLength(4)
})
it('wiederholt nach einem Neustart keine Frage, deren Bilder nicht mehr da sind', async () => {
desktop = await startFakeDesktop({ reply: 'A cat.' })
const mem = asyncMemoryStorage()
const first = await open({ storage: mem.storage })
await first.useStore.getState().connect(desktop.url, '123456')
desktop.backendDown = true
await first.useStore.getState().sendMessage('What is this?', { images: [photo] })
expect(first.useStore.getState().chats[0].messages[1].state).toBe('failed')
await first.flush()
desktop.backendDown = false
const second = createRemoteClientStore({ storage: mem.storage, persistWaitMs: 60_000 })
await second.ready
const b = () => second.useStore.getState()
await expect.poll(() => b().status).toBe('connected')
const before = desktop.chatRequests.length
expect(await b().retryLast()).toBe('images-lost')
expect(desktop.chatRequests.length).toBe(before)
// Die gescheiterte Antwort bleibt stehen, nichts wurde weggeworfen.
expect(b().chats[0].messages).toHaveLength(2)
expect(b().chats[0].messages[0].images?.[0].thumb).toBe('dGh1bWI=')
})
it('wirft ein uebergrosses oder unlesbares Vorschaubild weg, ohne die Nachricht zu verlieren', async () => {
desktop = await startFakeDesktop()
const { s } = await paired()
await s().sendMessage('Look', { images: [{ mimeType: 'text/html', thumb: '<script>', data: 'ZGF0YQ==' }] })
expect(s().chats[0].messages[0].images).toEqual([{ mimeType: 'image/jpeg', thumb: '' }])
})
})
describe('Runde 2: Chats gehoeren einem Desktop', () => {
it('ordnet einen neuen Chat dem verbundenen Desktop zu und merkt sich dessen Namen', async () => {
desktop = await startFakeDesktop({ hostname: 'Studio Mac' })
const { s } = await paired()
expect(s().connection?.hostName).toBe('Studio Mac')
await s().sendMessage('Hi')
expect(s().chats[0].baseUrl).toBe(desktop.url)
})
it('setzt einen Chat eines anderen Desktops nicht fort und aendert ihn nicht', async () => {
desktop = await startFakeDesktop({ reply: 'From the first.' })
const { s } = await paired()
await s().sendMessage('Hi first')
const oldId = s().chats[0].id
const other = await startFakeDesktop({ models: ['other:1b'], reply: 'From the second.' })
try {
await s().connect(other.url, '123456')
expect(s().status).toBe('connected')
s().selectChat(oldId)
expect(await s().sendMessage('Hi again')).toBe('other-desktop')
expect(await s().retryLast(oldId)).toBe('other-desktop')
const old = s().chats.find((c) => c.id === oldId)!
expect(old.messages).toHaveLength(2)
// Das Modell des alten Chats wird nicht auf eins des neuen Desktops umgeschrieben.
expect(old.model).toBe('qwen3:8b')
expect(other.chatRequests).toHaveLength(0)
const fresh = s().newChat()
expect(await s().sendMessage('Hi second')).toBe('sent')
expect(s().chats.find((c) => c.id === fresh)).toMatchObject({ baseUrl: other.url, model: 'other:1b' })
} finally {
await other.stop()
}
})
it('ordnet Chats aus einem Stand ohne diese Angabe dem gespeicherten Desktop zu', async () => {
desktop = await startFakeDesktop()
const legacy = {
state: {
connection: { baseUrl: desktop.url, address: `127.0.0.1:${desktop.port}`, route: 'loopback', secure: false, pairedAt: 1, lastOkAt: 1, serverVersion: '3.0.5' },
chats: [
{
id: 'c-old',
title: 'Old',
model: 'qwen3:8b',
thinkEnabled: false,
systemPrompt: null,
createdAt: 1,
updatedAt: 1,
messages: [{ id: 'm1', role: 'user', content: 'Hi', thinking: '', createdAt: 1, state: 'done' }],
},
],
activeChatId: 'c-old',
drafts: {},
},
version: 1,
}
const mem = asyncMemoryStorage({ [REMOTE_STORE_KEY]: JSON.stringify(legacy) })
const store = await open({ storage: mem.storage })
const chat = store.useStore.getState().chats[0]
expect(chat).toMatchObject({ baseUrl: desktop.url, agentMode: false, caveman: 'off' })
expect(store.useStore.getState().connection?.hostName).toBe('')
})
it('macht aus einem Werkzeugschritt, der beim Beenden noch lief, einen gescheiterten', async () => {
desktop = await startFakeDesktop()
const saved = {
state: {
connection: null,
chats: [
{
id: 'c1',
title: 'T',
model: 'm',
thinkEnabled: false,
systemPrompt: null,
agentMode: true,
caveman: 'lite',
baseUrl: 'http://10.0.0.5:11435',
createdAt: 1,
updatedAt: 1,
messages: [
{ id: 'm1', role: 'user', content: 'Go', thinking: '', createdAt: 1, state: 'done' },
{
id: 'm2',
role: 'assistant',
content: '',
thinking: '',
createdAt: 2,
state: 'pending',
steps: [
{ id: 's1', tool: 'file_read', args: '{}', state: 'running', result: '' },
{ tool: 7 },
// A17: what image_generate made stays as a reference to the phone gallery; nothing else is taken.
{
id: 's2',
tool: 'image_generate',
args: '{}',
state: 'done',
result: 'ok',
media: [{ id: `pc_res_${'c'.repeat(32)}`, kind: 'image', mime: 'image/png' }, { id: 'https://evil.example/x.png', kind: 'image' }, { id: 'pc_x', kind: 'audio' }],
},
],
},
],
},
],
activeChatId: 'c1',
drafts: {},
},
version: 1,
}
const mem = asyncMemoryStorage({ [REMOTE_STORE_KEY]: JSON.stringify(saved) })
const store = await open({ storage: mem.storage })
const chat = store.useStore.getState().chats[0]
expect(chat).toMatchObject({ agentMode: true, caveman: 'lite', baseUrl: 'http://10.0.0.5:11435' })
expect(chat.messages[1].state).toBe('interrupted')
expect(chat.messages[1].steps).toEqual([
{ id: 's1', tool: 'file_read', args: '{}', state: 'failed', result: '' },
{ id: 's2', tool: 'image_generate', args: '{}', state: 'done', result: 'ok', media: [{ id: `pc_res_${'c'.repeat(32)}`, kind: 'image', mime: 'image/png' }] },
])
})
})