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.

7.6 KB
Raw Blame
import { z } from 'zod'
import { isTuiAgent } from '../tui-agent-config'
import {
  OptionalBoolean,
  OptionalPlainString,
  OptionalPositiveInt,
  OptionalString,
  requiredNumber,
  requiredString
} from './rpc-param-primitives'
import { normalizeExecutionHostId } from '../execution-host'
import { isValidAutomationSchedule } from '../automation-schedule-parsing'
import {
  MAX_AUTOMATION_PRECHECK_TIMEOUT_SECONDS,
  normalizeAutomationPrecheckTimeoutSeconds
} from '../automation-precheck'

export const TuiAgent = requiredString('Missing provider').refine(isTuiAgent, {
  message: 'Unknown provider'
})

export const AutomationWorkspaceMode = z.enum(['existing', 'new_per_run']).optional()

export const SetupDecision = z.enum(['inherit', 'run', 'skip']).optional()

export const ExecutionHostId = requiredString('Missing host id').transform((value, ctx) => {
  const hostId = normalizeExecutionHostId(value)
  if (!hostId) {
    ctx.addIssue({ code: 'custom', message: 'Invalid host id' })
    return z.NEVER
  }
  return hostId
})

export const AutomationSchedule = requiredString('Missing trigger').refine(
  isValidAutomationSchedule,
  {
    message: 'Invalid automation trigger'
  }
)

export const AutomationPrecheck = z
  .object({
    command: requiredString('Missing precheck command'),
    timeoutSeconds: OptionalPositiveInt.transform((value) =>
      normalizeAutomationPrecheckTimeoutSeconds(value)
    ).refine((value) => value <= MAX_AUTOMATION_PRECHECK_TIMEOUT_SECONDS, {
      message: 'Precheck timeout is too large'
    })
  })
  .nullable()
  .optional()

export const OptionalNullablePlainString = z
  .unknown()
  .transform((value) => (value === null || typeof value === 'string' ? value : undefined))
  .pipe(z.union([z.string(), z.null(), z.undefined()]))
  .optional()

// A GitHub identity is only usable with both fields present and non-blank.
const GithubIdentityField = z.string().refine((value) => value.trim().length > 0, {
  message: 'Required'
})

export const TaskProviderIdentity = z
  .discriminatedUnion('provider', [
    z
      .object({
        provider: z.literal('github'),
        // Reject blank identity without trimming: normalization treats it as absent, but parsing must preserve nonblank bytes.
        owner: GithubIdentityField,
        repo: GithubIdentityField,
        host: z.string().optional()
      })
      .passthrough(),
    z
      .object({
        provider: z.literal('gitlab'),
        projectId: z.string().nullable().optional(),
        namespace: z.string().nullable().optional(),
        project: z.string().nullable().optional(),
        webUrl: z.string().nullable().optional()
      })
      .passthrough(),
    z
      .object({
        provider: z.literal('linear'),
        workspaceId: z.string().nullable().optional(),
        workspaceName: z.string().nullable().optional(),
        teamId: z.string().nullable().optional(),
        teamKey: z.string().nullable().optional()
      })
      .passthrough(),
    z
      .object({
        provider: z.literal('jira'),
        siteId: z.string().nullable().optional(),
        siteUrl: z.string().nullable().optional(),
        projectKey: z.string().nullable().optional()
      })
      .passthrough()
  ])
  .optional()
  .nullable()

export const TaskSourceContext = z
  .object({
    kind: z.literal('task-source'),
    provider: z.enum(['github', 'gitlab', 'linear', 'jira']),
    projectId: requiredString('Missing source project id'),
    hostId: ExecutionHostId,
    projectHostSetupId: OptionalNullablePlainString,
    repoId: OptionalNullablePlainString,
    providerIdentity: TaskProviderIdentity,
    accountLabel: OptionalNullablePlainString
  })
  .optional()
  .nullable()

export const WorkspaceRunContext = z
  .object({
    kind: z.literal('workspace-run'),
    projectId: requiredString('Missing run project id'),
    hostId: ExecutionHostId,
    projectHostSetupId: requiredString('Missing project host setup id'),
    repoId: requiredString('Missing repo id'),
    path: requiredString('Missing run path')
  })
  .optional()
  .nullable()

export const SshTargetGeneration = requiredNumber('Missing SSH target generation').refine(
  (value) => Number.isSafeInteger(value) && value >= 1,
  { message: 'Invalid SSH target generation' }
)

export const OwnedSshSelector = z.object({
  kind: z.literal('ssh'),
  targetId: requiredString('Missing SSH target id'),
  targetGeneration: SshTargetGeneration
})

/** Orphan is accepted here, unlike a destination: a record with no executable host is still deletable. */
export const OwnerPreconditionSelector = z.discriminatedUnion('kind', [
  z.object({ kind: z.literal('self') }),
  OwnedSshSelector,
  z.object({ kind: z.literal('orphan') })
])

export const DestinationSelector = z.discriminatedUnion('kind', [
  z.object({ kind: z.literal('self') }),
  OwnedSshSelector
])

export const ExpectedOwner = z.object({ selector: OwnerPreconditionSelector }).optional()

export const Destination = z.object({ selector: DestinationSelector }).optional()

export const ListScopeSelector = z.discriminatedUnion('kind', [
  z.object({ kind: z.literal('self') }),
  z.object({
    kind: z.literal('ssh'),
    targetId: requiredString('Missing SSH target id'),
    expectedTargetGeneration: SshTargetGeneration
  }),
  z.object({ kind: z.literal('orphan') })
])

/** An omitted selector is the legacy request; old clients keep the authority's complete list. */
export const AutomationList = z.object({ selector: ListScopeSelector.optional() })

export const AutomationId = z.object({
  id: requiredString('Missing automation id'),
  expectedOwner: ExpectedOwner
})

export const AutomationRuns = z.object({
  automationId: OptionalString,
  expectedOwner: ExpectedOwner,
  limit: OptionalPositiveInt,
  cursor: OptionalString
})

// Why strict: null or a non-string must fail rather than fall back to "omitted", which preserves.
const ExtraAgentArgs = z.string({ message: 'Extra agent arguments must be text.' }).optional()

export const AutomationCreate = z.object({
  creationKey: OptionalString,
  name: requiredString('Missing automation name'),
  prompt: requiredString('Missing automation prompt'),
  precheck: AutomationPrecheck,
  agentId: TuiAgent,
  extraAgentArgs: ExtraAgentArgs,
  runContext: WorkspaceRunContext,
  sourceContext: TaskSourceContext,
  repo: OptionalString,
  workspace: OptionalString,
  workspaceMode: AutomationWorkspaceMode,
  baseBranch: OptionalPlainString,
  setupDecision: SetupDecision,
  reuseSession: OptionalBoolean,
  timezone: OptionalString,
  rrule: AutomationSchedule,
  dtstart: requiredNumber('Missing trigger start time'),
  enabled: OptionalBoolean,
  missedRunGraceMinutes: OptionalPositiveInt,
  destination: Destination
})

export const AutomationUpdateFields = z.object({
  name: OptionalString,
  prompt: OptionalString,
  precheck: AutomationPrecheck,
  agentId: TuiAgent.optional(),
  extraAgentArgs: ExtraAgentArgs,
  runContext: WorkspaceRunContext,
  sourceContext: TaskSourceContext,
  repo: OptionalString,
  workspace: OptionalString,
  workspaceMode: AutomationWorkspaceMode,
  // Why: update patches distinguish omitted from null so callers can clear a saved base branch.
  baseBranch: OptionalNullablePlainString,
  setupDecision: SetupDecision,
  reuseSession: OptionalBoolean,
  timezone: OptionalString,
  rrule: AutomationSchedule.optional(),
  dtstart: requiredNumber('Missing trigger start time').optional(),
  enabled: OptionalBoolean,
  missedRunGraceMinutes: OptionalPositiveInt
})

export const AutomationUpdate = z.object({
  id: requiredString('Missing automation id'),
  updates: AutomationUpdateFields,
  expectedOwner: ExpectedOwner,
  destination: Destination
})