Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import { describe, expect, it } from 'vitest'
import {
AiVaultSearchRequestSchema,
AiVaultSearchResponseSchema,
AiVaultSearchStatusSchema
} from './ai-vault-search-contract'
import { searchHit, searchResults } from './ai-vault-search-test-fixture'
import { redactForTransport, redactStatusForTransport } from './ai-vault-search-transport'
import { unavailableSessionSearchStatus } from './ai-vault-search-client'
describe('session search public contract', () => {
it('drops legacy fields without letting them override scope or freshness', () => {
expect(
AiVaultSearchRequestSchema.parse({ query: 'needle', tier: 'conversation', refresh: true })
).toEqual({ query: 'needle', limit: 20 })
})
it.each([
[0, 1],
[-4, 1],
[200, 100],
[2.5, 20],
[undefined, 20]
])('clamps %s to %s', (limit, expected) => {
expect(AiVaultSearchRequestSchema.parse({ query: 'needle', limit }).limit).toBe(expected)
})
it.each(['2026-10-12T00:00:00Z', '2026-10-12T08:00:00+08:00', '2026-10-11T16:00:00-08:00'])(
'reads since %s as the stored UTC instant',
(since) => {
expect(AiVaultSearchRequestSchema.parse({ query: 'q', filters: { since } }).filters).toEqual({
since: '2026-10-12T00:00:00.000Z'
})
}
)
it('preserves long query text in the request schema', () => {
const query = 'needle '.repeat(100)
expect(AiVaultSearchRequestSchema.parse({ query }).query).toBe(query)
})
it('validates every response variant and separate status', () => {
for (const response of [
searchResults(),
{ kind: 'malformed-cursor' },
{ kind: 'stale-cursor', generation: 2, expectedGeneration: 1 },
...['disabled', 'not-ready', 'no-service'].map((reason) => ({ kind: 'unavailable', reason }))
]) {
expect(AiVaultSearchResponseSchema.parse(response)).toEqual(response)
}
expect(AiVaultSearchStatusSchema.parse(unavailableSessionSearchStatus())).toEqual(
unavailableSessionSearchStatus()
)
expect(AiVaultSearchResponseSchema.safeParse({ kind: 'results', hits: [] }).success).toBe(false)
})
it('keeps host attribution optional in both wire directions', () => {
const legacy = searchResults()
expect(AiVaultSearchResponseSchema.parse(legacy)).toEqual(legacy)
expect(legacy.hits[0]).not.toHaveProperty('executionHostId')
const attributed = {
...searchResults(),
hits: [{ ...searchHit(), executionHostId: 'runtime:env-1' }]
}
expect(AiVaultSearchResponseSchema.parse(attributed)).toEqual(attributed)
expect(
AiVaultSearchResponseSchema.safeParse({
...searchResults(),
hits: [{ ...searchHit(), executionHostId: '' }]
}).success
).toBe(false)
})
it('accepts future agent names only in optional capability lists', () => {
const supportedAgents = ['codex', 'jcode', 'future-agent']
expect(
AiVaultSearchRequestSchema.parse({ query: 'q', supportedAgents }).supportedAgents
).toEqual(supportedAgents)
expect(
AiVaultSearchStatusSchema.parse({ ...unavailableSessionSearchStatus(), supportedAgents })
.supportedAgents
).toEqual(supportedAgents)
expect(
AiVaultSearchRequestSchema.safeParse({ query: 'q', filters: { agents: ['future-agent'] } })
.success
).toBe(false)
})
it('never accepts resume commands for an unverified or missing source', () => {
for (const presence of ['unverifiable', 'missing'] as const) {
const response = searchResults()
response.hits[0].source.presence = presence
expect(AiVaultSearchResponseSchema.safeParse(response).success).toBe(false)
}
})
it.each(['ipc', 'runtime', 'relay'] as const)(
'enforces the %s exposure policy without mutating the hit',
(transport) => {
const hit = searchHit()
const original = structuredClone(hit)
const result = redactForTransport(hit, transport)
expect(hit).toEqual(original)
expect(result.cwd).toBe('/host/folder')
if (transport === 'relay') {
expect(result.source).toEqual({ presence: 'present' })
expect(result).not.toHaveProperty('resumeCommand')
} else {
expect(result).toEqual(hit)
}
for (const presence of ['unverifiable', 'missing'] as const) {
expect(
redactForTransport({ ...hit, source: { ...hit.source, presence } }, transport)
).not.toHaveProperty('resumeCommand')
}
}
)
it.each(['ipc', 'runtime', 'relay'] as const)(
'withholds degraded-root paths from %s status without mutating it',
(transport) => {
const status = {
...unavailableSessionSearchStatus(),
degradedRoots: [{ root: '/host/projects', reason: 'could not be listed' }]
}
const original = structuredClone(status)
const result = redactStatusForTransport(status, transport)
expect(status).toEqual(original)
expect(AiVaultSearchStatusSchema.parse(result)).toEqual(result)
expect(result.degradedRoots).toEqual([
transport === 'relay'
? { reason: 'Source root could not be verified.' }
: { root: '/host/projects', reason: 'could not be listed' }
])
}
)
it.each([
'/host/private/path could not be listed.',
"EACCES: permission denied, scandir '/host/private/path'",
"EACCES: permission denied, scandir 'C:\\Users\\private\\sessions'"
])('withholds paths embedded in relay diagnostics: %s', (reason) => {
const status = {
...unavailableSessionSearchStatus(),
degradedRoots: [{ root: '/host/private/path', reason }]
}
const result = redactStatusForTransport(status, 'relay')
expect(result.degradedRoots).toHaveLength(1)
expect(JSON.stringify(result)).not.toContain('/host/private/path')
expect(JSON.stringify(result)).not.toContain('private')
expect(redactStatusForTransport(status, 'runtime')).toEqual(status)
})
})