mirror of
https://github.com/getpaseo/paseo.git
synced 2026-10-27 03:32:55 +00:00
420 lines
11 KiB
TypeScript
420 lines
11 KiB
TypeScript
import type { Command } from 'commander'
|
|
import type { AgentSnapshotPayload } from '@getpaseo/server'
|
|
import { connectToDaemon, getDaemonHost } from '../../utils/client.js'
|
|
import type { CommandOptions, SingleResult, OutputSchema, CommandError } from '../../output/index.js'
|
|
import { readFileSync } from 'node:fs'
|
|
import { resolve } from 'node:path'
|
|
import { lookup } from 'mime-types'
|
|
|
|
/** Result type for agent run command */
|
|
export interface AgentRunResult {
|
|
agentId: string
|
|
status: 'created' | 'running' | 'completed' | 'timeout' | 'permission' | 'error'
|
|
provider: string
|
|
cwd: string
|
|
title: string | null
|
|
}
|
|
|
|
/** Schema for agent run output */
|
|
export const agentRunSchema: OutputSchema<AgentRunResult> = {
|
|
idField: 'agentId',
|
|
columns: [
|
|
{ header: 'AGENT ID', field: 'agentId', width: 12 },
|
|
{ header: 'STATUS', field: 'status', width: 10 },
|
|
{ header: 'PROVIDER', field: 'provider', width: 10 },
|
|
{ header: 'CWD', field: 'cwd', width: 30 },
|
|
{ header: 'TITLE', field: 'title', width: 20 },
|
|
],
|
|
}
|
|
|
|
export interface AgentRunOptions extends CommandOptions {
|
|
detach?: boolean
|
|
name?: string
|
|
provider?: string
|
|
model?: string
|
|
mode?: string
|
|
worktree?: string
|
|
base?: string
|
|
image?: string[]
|
|
cwd?: string
|
|
label?: string[]
|
|
ui?: boolean
|
|
outputSchema?: string
|
|
}
|
|
|
|
function toRunResult(
|
|
agent: AgentSnapshotPayload,
|
|
statusOverride?: AgentRunResult['status']
|
|
): AgentRunResult {
|
|
return {
|
|
agentId: agent.id,
|
|
status: statusOverride ?? (agent.status === 'running' ? 'running' : 'created'),
|
|
provider: agent.provider,
|
|
cwd: agent.cwd,
|
|
title: agent.title,
|
|
}
|
|
}
|
|
|
|
function loadOutputSchema(value: string): Record<string, unknown> {
|
|
const trimmed = value.trim()
|
|
if (!trimmed) {
|
|
const error: CommandError = {
|
|
code: 'INVALID_OUTPUT_SCHEMA',
|
|
message: '--output-schema cannot be empty',
|
|
details: 'Provide a JSON schema file path or inline JSON object',
|
|
}
|
|
throw error
|
|
}
|
|
|
|
let source = trimmed
|
|
if (!trimmed.startsWith('{')) {
|
|
try {
|
|
source = readFileSync(resolve(trimmed), 'utf8')
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : String(err)
|
|
const error: CommandError = {
|
|
code: 'INVALID_OUTPUT_SCHEMA',
|
|
message: `Failed to read output schema file: ${trimmed}`,
|
|
details: message,
|
|
}
|
|
throw error
|
|
}
|
|
}
|
|
|
|
let parsed: unknown
|
|
try {
|
|
parsed = JSON.parse(source)
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : String(err)
|
|
const error: CommandError = {
|
|
code: 'INVALID_OUTPUT_SCHEMA',
|
|
message: 'Failed to parse output schema JSON',
|
|
details: message,
|
|
}
|
|
throw error
|
|
}
|
|
|
|
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
|
|
const error: CommandError = {
|
|
code: 'INVALID_OUTPUT_SCHEMA',
|
|
message: 'Output schema must be a JSON object',
|
|
}
|
|
throw error
|
|
}
|
|
|
|
return parsed as Record<string, unknown>
|
|
}
|
|
|
|
function extractFirstJsonObject(text: string): string | null {
|
|
const source = text.trim()
|
|
if (!source) {
|
|
return null
|
|
}
|
|
|
|
const startIndexes: number[] = []
|
|
for (let i = 0; i < source.length; i += 1) {
|
|
if (source[i] === '{') {
|
|
startIndexes.push(i)
|
|
}
|
|
}
|
|
|
|
for (const start of startIndexes) {
|
|
let depth = 0
|
|
let inString = false
|
|
let escaped = false
|
|
|
|
for (let i = start; i < source.length; i += 1) {
|
|
const ch = source[i]!
|
|
|
|
if (inString) {
|
|
if (escaped) {
|
|
escaped = false
|
|
continue
|
|
}
|
|
if (ch === '\\') {
|
|
escaped = true
|
|
continue
|
|
}
|
|
if (ch === '"') {
|
|
inString = false
|
|
}
|
|
continue
|
|
}
|
|
|
|
if (ch === '"') {
|
|
inString = true
|
|
continue
|
|
}
|
|
|
|
if (ch === '{') {
|
|
depth += 1
|
|
continue
|
|
}
|
|
if (ch === '}') {
|
|
depth -= 1
|
|
if (depth === 0) {
|
|
const candidate = source.slice(start, i + 1).trim()
|
|
try {
|
|
JSON.parse(candidate)
|
|
return candidate
|
|
} catch {
|
|
// Keep scanning.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return null
|
|
}
|
|
|
|
function parseStructuredOutput(lastMessage: string): Record<string, unknown> {
|
|
const trimmed = lastMessage.trim()
|
|
const fenced = trimmed.match(/```(?:json)?\s*\n([\s\S]*?)\n```/)
|
|
const jsonText = fenced?.[1]?.trim() ?? extractFirstJsonObject(trimmed) ?? trimmed
|
|
|
|
let parsed: unknown
|
|
try {
|
|
parsed = JSON.parse(jsonText)
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : String(err)
|
|
const error: CommandError = {
|
|
code: 'OUTPUT_SCHEMA_FAILED',
|
|
message: 'Agent response is not valid JSON',
|
|
details: message,
|
|
}
|
|
throw error
|
|
}
|
|
|
|
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
|
|
const error: CommandError = {
|
|
code: 'OUTPUT_SCHEMA_FAILED',
|
|
message: 'Agent response JSON must be an object',
|
|
}
|
|
throw error
|
|
}
|
|
|
|
return parsed as Record<string, unknown>
|
|
}
|
|
|
|
function structuredRunSchema(output: Record<string, unknown>): OutputSchema<AgentRunResult> {
|
|
return {
|
|
...agentRunSchema,
|
|
serialize: () => output,
|
|
}
|
|
}
|
|
|
|
export async function runRunCommand(
|
|
prompt: string,
|
|
options: AgentRunOptions,
|
|
_command: Command
|
|
): Promise<SingleResult<AgentRunResult>> {
|
|
const host = getDaemonHost({ host: options.host as string | undefined })
|
|
const outputSchema = options.outputSchema ? loadOutputSchema(options.outputSchema) : undefined
|
|
|
|
// Validate prompt is provided
|
|
if (!prompt || prompt.trim().length === 0) {
|
|
const error: CommandError = {
|
|
code: 'MISSING_PROMPT',
|
|
message: 'A prompt is required',
|
|
details: 'Usage: paseo agent run [options] <prompt>',
|
|
}
|
|
throw error
|
|
}
|
|
|
|
// Validate --base is only used with --worktree
|
|
if (options.base && !options.worktree) {
|
|
const error: CommandError = {
|
|
code: 'INVALID_OPTIONS',
|
|
message: '--base can only be used with --worktree',
|
|
details: 'Usage: paseo agent run --worktree <name> --base <branch> <prompt>',
|
|
}
|
|
throw error
|
|
}
|
|
|
|
// --output-schema always runs in attached/wait mode
|
|
if (outputSchema && options.detach) {
|
|
const error: CommandError = {
|
|
code: 'INVALID_OPTIONS',
|
|
message: '--output-schema cannot be used with --detach',
|
|
details: 'Structured output requires waiting for the agent to finish',
|
|
}
|
|
throw error
|
|
}
|
|
|
|
let client
|
|
try {
|
|
client = await connectToDaemon({ host: options.host as string | undefined })
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : String(err)
|
|
const error: CommandError = {
|
|
code: 'DAEMON_NOT_RUNNING',
|
|
message: `Cannot connect to daemon at ${host}: ${message}`,
|
|
details: 'Start the daemon with: paseo daemon start',
|
|
}
|
|
throw error
|
|
}
|
|
|
|
try {
|
|
// Resolve working directory
|
|
const cwd = options.cwd ?? process.cwd()
|
|
|
|
// Process images if provided
|
|
let images: Array<{ data: string; mimeType: string }> | undefined
|
|
if (options.image && options.image.length > 0) {
|
|
images = options.image.map((imagePath) => {
|
|
const resolvedPath = resolve(imagePath)
|
|
try {
|
|
const imageData = readFileSync(resolvedPath)
|
|
const mimeType = lookup(resolvedPath) || 'application/octet-stream'
|
|
|
|
// Verify it's an image MIME type
|
|
if (!mimeType.startsWith('image/')) {
|
|
throw new Error(`File is not an image: ${imagePath} (detected type: ${mimeType})`)
|
|
}
|
|
|
|
return {
|
|
data: imageData.toString('base64'),
|
|
mimeType,
|
|
}
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : String(err)
|
|
throw new Error(`Failed to read image ${imagePath}: ${message}`)
|
|
}
|
|
})
|
|
}
|
|
|
|
// Build git options if worktree is specified
|
|
const git = options.worktree
|
|
? {
|
|
createWorktree: true,
|
|
worktreeSlug: options.worktree,
|
|
baseBranch: options.base,
|
|
}
|
|
: undefined
|
|
|
|
// Build labels from --label and --ui flags
|
|
// --ui is syntactic sugar for --label ui=true
|
|
// If explicit --label ui=... is provided, it takes precedence over --ui
|
|
const labels: Record<string, string> = {}
|
|
if (options.label) {
|
|
for (const labelStr of options.label) {
|
|
const eqIndex = labelStr.indexOf('=')
|
|
if (eqIndex === -1) {
|
|
const error: CommandError = {
|
|
code: 'INVALID_LABEL',
|
|
message: `Invalid label format: ${labelStr}`,
|
|
details: 'Labels must be in key=value format',
|
|
}
|
|
throw error
|
|
}
|
|
const key = labelStr.slice(0, eqIndex)
|
|
const value = labelStr.slice(eqIndex + 1)
|
|
labels[key] = value
|
|
}
|
|
}
|
|
// Add ui=true if --ui flag is set and ui label not already set
|
|
if (options.ui && !('ui' in labels)) {
|
|
labels['ui'] = 'true'
|
|
}
|
|
|
|
// Create the agent
|
|
const agent = await client.createAgent({
|
|
provider: (options.provider as 'claude' | 'codex' | 'opencode') ?? 'claude',
|
|
cwd,
|
|
title: options.name,
|
|
modeId: options.mode,
|
|
model: options.model,
|
|
initialPrompt: prompt,
|
|
outputSchema,
|
|
images,
|
|
git,
|
|
worktreeName: options.worktree,
|
|
labels: Object.keys(labels).length > 0 ? labels : undefined,
|
|
})
|
|
|
|
if (outputSchema) {
|
|
const state = await client.waitForFinish(agent.id, 10 * 60 * 1000)
|
|
|
|
if (state.status === 'timeout') {
|
|
const error: CommandError = {
|
|
code: 'OUTPUT_SCHEMA_FAILED',
|
|
message: 'Timed out waiting for structured output',
|
|
}
|
|
throw error
|
|
}
|
|
|
|
if (state.status === 'permission') {
|
|
const error: CommandError = {
|
|
code: 'OUTPUT_SCHEMA_FAILED',
|
|
message: 'Agent is waiting for permission before producing structured output',
|
|
}
|
|
throw error
|
|
}
|
|
|
|
if (state.status === 'error') {
|
|
const error: CommandError = {
|
|
code: 'OUTPUT_SCHEMA_FAILED',
|
|
message: state.error ?? 'Agent failed before producing structured output',
|
|
}
|
|
throw error
|
|
}
|
|
|
|
const lastMessage = state.lastMessage?.trim()
|
|
if (!lastMessage) {
|
|
const error: CommandError = {
|
|
code: 'OUTPUT_SCHEMA_FAILED',
|
|
message: 'Agent finished without a structured output message',
|
|
}
|
|
throw error
|
|
}
|
|
|
|
const output = parseStructuredOutput(lastMessage)
|
|
await client.close()
|
|
|
|
return {
|
|
type: 'single',
|
|
data: toRunResult(agent, 'completed'),
|
|
schema: structuredRunSchema(output),
|
|
}
|
|
}
|
|
|
|
// Default run behavior is foreground: wait for completion unless --detach is set.
|
|
if (!options.detach) {
|
|
const state = await client.waitForFinish(agent.id, 10 * 60 * 1000)
|
|
await client.close()
|
|
|
|
const finalAgent = state.final ?? agent
|
|
const status: AgentRunResult['status'] =
|
|
state.status === 'idle' ? 'completed' : state.status
|
|
|
|
return {
|
|
type: 'single',
|
|
data: toRunResult(finalAgent, status),
|
|
schema: agentRunSchema,
|
|
}
|
|
}
|
|
|
|
await client.close()
|
|
|
|
return {
|
|
type: 'single',
|
|
data: toRunResult(agent),
|
|
schema: agentRunSchema,
|
|
}
|
|
} catch (err) {
|
|
await client.close().catch(() => {})
|
|
|
|
if (err && typeof err === 'object' && 'code' in err) {
|
|
throw err
|
|
}
|
|
|
|
const message = err instanceof Error ? err.message : String(err)
|
|
const error: CommandError = {
|
|
code: 'AGENT_CREATE_FAILED',
|
|
message: `Failed to create agent: ${message}`,
|
|
}
|
|
throw error
|
|
}
|
|
}
|