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.

6.5 KB
Raw Blame
import {
  parseAgentStatusProviderAlias,
  isAgentStatusRunId,
  type AgentStatusProviderAlias,
  type AgentStatusRunId
} from './agent-status-run'
import {
  parseAgentStatusExecutionScope,
  type AgentStatusExecutionScope
} from './agent-status-subject'
import { assertJsonTextStructureWithinLimits } from './json-text-structure-limit'
import { measureUtf8ByteLength } from './utf8-byte-limits'

const PROVIDER_ALIAS_KEY_PREFIX = 'agent-status-provider-alias-v1:'
const MAX_ALIAS_INDEX_ENTRIES = 4096
const MAX_ALIAS_INDEX_RUN_REFERENCES = 16_384
const MAX_ALIAS_INDEX_SERIALIZED_BYTES = 4 * 1024 * 1024
const ALIAS_INDEX_JSON_STRUCTURE_LIMITS = {
  structuralTokens: 64 * 1024,
  nestingDepth: 3
} as const

export type AgentStatusScopedProviderAlias = AgentStatusExecutionScope & AgentStatusProviderAlias
export type AgentStatusProviderAliasKey = string

/** One provider tuple can resolve to multiple concurrently live run ids. */
export type AgentStatusRunAliasIndex = Map<AgentStatusProviderAliasKey, Set<AgentStatusRunId>>

type ProviderAliasKeyTuple = readonly [
  executionHostId: string,
  wslDistro: string | null,
  workspaceId: string,
  workspaceKind: AgentStatusExecutionScope['workspaceKind'],
  provider: AgentStatusProviderAlias['provider'],
  sessionKeyKind: AgentStatusProviderAlias['sessionKeyKind'],
  providerId: string
]

type SerializedAliasIndexEntry = {
  alias: string
  runIds: AgentStatusRunId[]
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value)
}

function hasExactKeys(record: Record<string, unknown>, keys: readonly string[]): boolean {
  const actualKeys = Object.keys(record)
  return actualKeys.length === keys.length && actualKeys.every((key) => keys.includes(key))
}

export function parseAgentStatusScopedProviderAlias(
  value: unknown
): AgentStatusScopedProviderAlias | null {
  if (
    !isRecord(value) ||
    !hasExactKeys(value, [
      'executionHostId',
      'wslDistro',
      'workspaceId',
      'workspaceKind',
      'provider',
      'sessionKeyKind',
      'providerId'
    ])
  ) {
    return null
  }
  const scope = parseAgentStatusExecutionScope({
    executionHostId: value.executionHostId,
    wslDistro: value.wslDistro,
    workspaceId: value.workspaceId,
    workspaceKind: value.workspaceKind
  })
  const alias = parseAgentStatusProviderAlias({
    provider: value.provider,
    sessionKeyKind: value.sessionKeyKind,
    providerId: value.providerId
  })
  return scope && alias ? { ...scope, ...alias } : null
}

function providerAliasKeyTuple(alias: AgentStatusScopedProviderAlias): ProviderAliasKeyTuple {
  return [
    alias.executionHostId,
    alias.wslDistro,
    alias.workspaceId,
    alias.workspaceKind,
    alias.provider,
    alias.sessionKeyKind,
    alias.providerId
  ]
}

export function serializeAgentStatusProviderAliasKey(
  alias: AgentStatusScopedProviderAlias
): AgentStatusProviderAliasKey {
  const parsed = parseAgentStatusScopedProviderAlias(alias)
  if (!parsed) {
    throw new Error('Invalid agent status provider alias')
  }
  return `${PROVIDER_ALIAS_KEY_PREFIX}${JSON.stringify(providerAliasKeyTuple(parsed))}`
}

export function deserializeAgentStatusProviderAliasKey(
  value: AgentStatusProviderAliasKey
): AgentStatusScopedProviderAlias | null {
  if (!value.startsWith(PROVIDER_ALIAS_KEY_PREFIX)) {
    return null
  }
  let tuple: unknown
  try {
    tuple = JSON.parse(value.slice(PROVIDER_ALIAS_KEY_PREFIX.length))
  } catch {
    return null
  }
  if (!Array.isArray(tuple) || tuple.length !== 7) {
    return null
  }
  const [
    executionHostId,
    wslDistro,
    workspaceId,
    workspaceKind,
    provider,
    sessionKeyKind,
    providerId
  ] = tuple
  const alias = parseAgentStatusScopedProviderAlias({
    executionHostId,
    wslDistro,
    workspaceId,
    workspaceKind,
    provider,
    sessionKeyKind,
    providerId
  })
  return alias && serializeAgentStatusProviderAliasKey(alias) === value ? alias : null
}

export function serializeAgentStatusRunAliasIndex(
  index: ReadonlyMap<AgentStatusProviderAliasKey, ReadonlySet<AgentStatusRunId>>
): string {
  if (index.size > MAX_ALIAS_INDEX_ENTRIES) {
    throw new Error('Agent status alias index exceeds its entry limit')
  }
  const entries: SerializedAliasIndexEntry[] = []
  let runReferenceCount = 0
  for (const [aliasKey, runIds] of index) {
    if (!deserializeAgentStatusProviderAliasKey(aliasKey) || runIds.size === 0) {
      throw new Error('Invalid agent status alias index entry')
    }
    const serializedRunIds = [...runIds]
    if (!serializedRunIds.every(isAgentStatusRunId)) {
      throw new Error('Invalid agent status alias run id')
    }
    runReferenceCount += serializedRunIds.length
    if (runReferenceCount > MAX_ALIAS_INDEX_RUN_REFERENCES) {
      throw new Error('Agent status alias index exceeds its run-reference limit')
    }
    serializedRunIds.sort()
    entries.push({ alias: aliasKey, runIds: serializedRunIds })
  }
  entries.sort((left, right) => (left.alias < right.alias ? -1 : left.alias > right.alias ? 1 : 0))
  const serialized = JSON.stringify(entries)
  if (
    measureUtf8ByteLength(serialized, { stopAfterBytes: MAX_ALIAS_INDEX_SERIALIZED_BYTES })
      .exceededLimit
  ) {
    throw new Error('Agent status alias index exceeds its serialized-byte limit')
  }
  return serialized
}

export function deserializeAgentStatusRunAliasIndex(
  value: string
): AgentStatusRunAliasIndex | null {
  if (
    measureUtf8ByteLength(value, { stopAfterBytes: MAX_ALIAS_INDEX_SERIALIZED_BYTES }).exceededLimit
  ) {
    return null
  }
  let parsed: unknown
  try {
    assertJsonTextStructureWithinLimits(value, ALIAS_INDEX_JSON_STRUCTURE_LIMITS)
    parsed = JSON.parse(value)
  } catch {
    return null
  }
  if (!Array.isArray(parsed) || parsed.length > MAX_ALIAS_INDEX_ENTRIES) {
    return null
  }
  const index: AgentStatusRunAliasIndex = new Map()
  let runReferenceCount = 0
  for (const entry of parsed) {
    if (
      !isRecord(entry) ||
      !hasExactKeys(entry, ['alias', 'runIds']) ||
      typeof entry.alias !== 'string' ||
      !deserializeAgentStatusProviderAliasKey(entry.alias) ||
      !Array.isArray(entry.runIds) ||
      entry.runIds.length === 0 ||
      !entry.runIds.every(isAgentStatusRunId) ||
      new Set(entry.runIds).size !== entry.runIds.length ||
      index.has(entry.alias)
    ) {
      return null
    }
    runReferenceCount += entry.runIds.length
    if (runReferenceCount > MAX_ALIAS_INDEX_RUN_REFERENCES) {
      return null
    }
    index.set(entry.alias, new Set(entry.runIds))
  }
  return index
}