Skip to content

armgit / orca

Public Imported from GitHub
0

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.

5.8 KB
Raw Blame
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)
  })
})