jb/paseo
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(cli): rename ps to ls and add top-level agent commands

Browse Source
This commit is contained in:
Mohamed Boudra
2026-01-29 10:41:19 +07:00
parent 7d4636ecff
commit dfda6daeed
46 changed files with 4473 additions and 542 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/cli/src/commands/agent/logs.ts
+130 -85
View File
@@ -1,26 +1,12 @@
import type { Command } from 'commander'
import { connectToDaemon, getDaemonHost, resolveAgentId } from '../../utils/client.js'
import type { CommandOptions, ListResult, OutputSchema, CommandError } from '../../output/index.js'
import type { DaemonClientV2 } from '@paseo/server'
/** Message type for agent_stream_snapshot */
interface AgentStreamSnapshotMessage {
type: 'agent_stream_snapshot'
payload: {
agentId: string
events: Array<{ event: { type: string; item?: unknown }; timestamp: string }>
}
}
/** Message type for agent_stream */
interface AgentStreamMessage {
type: 'agent_stream'
payload: {
agentId: string
event: { type: string; item?: unknown }
timestamp: string
}
}
import type {
DaemonClientV2,
AgentStreamMessage,
AgentStreamSnapshotMessage,
AgentTimelineItem,
} from '@paseo/server'
/** Timeline item for display */
export interface LogEntry {
@@ -42,20 +28,14 @@ export const logsSchema: OutputSchema<LogEntry> = {
export interface AgentLogsOptions extends CommandOptions {
follow?: boolean
tail?: string
filter?: string
since?: string
}
export type AgentLogsResult = ListResult<LogEntry>
/** Format a timeline item into a log entry */
function formatTimelineItem(item: {
type: string
text?: string
name?: string
input?: unknown
status?: string
items?: { text: string; completed: boolean }[]
message?: string
}): LogEntry {
function formatTimelineItem(item: AgentTimelineItem): LogEntry {
const now = new Date().toISOString().slice(11, 19) // HH:MM:SS
switch (item.type) {
@@ -63,22 +43,22 @@ function formatTimelineItem(item: {
return {
timestamp: now,
type: 'user',
summary: truncate(item.text ?? '', 60),
summary: truncate(item.text, 60),
}
case 'assistant_message':
return {
timestamp: now,
type: 'assistant',
summary: truncate(item.text ?? '', 60),
summary: truncate(item.text, 60),
}
case 'reasoning':
return {
timestamp: now,
type: 'reasoning',
summary: truncate(item.text ?? '', 60),
summary: truncate(item.text, 60),
}
case 'tool_call': {
const toolName = item.name ?? 'unknown'
const toolName = item.name
const status = item.status ?? ''
let inputSummary = ''
if (item.input && typeof item.input === 'object') {
@@ -99,25 +79,18 @@ function formatTimelineItem(item: {
}
}
case 'todo': {
const items = item.items ?? []
const completed = items.filter((i) => i.completed).length
const completed = item.items.filter((i) => i.completed).length
return {
timestamp: now,
type: 'todo',
summary: `${completed}/${items.length} completed`,
summary: `${completed}/${item.items.length} completed`,
}
}
case 'error':
return {
timestamp: now,
type: 'error',
summary: truncate(item.message ?? '', 60),
}
default:
return {
timestamp: now,
type: item.type,
summary: '',
summary: truncate(item.message, 60),
}
}
}
@@ -129,22 +102,75 @@ function truncate(str: string, maxLen: number): string {
}
/**
* Extract timeline items from an agent_stream_snapshot message
* Check if a timeline item matches the filter type
*/
function extractTimelineFromSnapshot(
message: { type: string; payload: unknown }
): Array<{ type: string; [key: string]: unknown }> {
if (message.type !== 'agent_stream_snapshot') return []
function matchesFilter(item: AgentTimelineItem, filter?: string): boolean {
if (!filter) return true
const payload = message.payload as {
agentId: string
events: Array<{ event: { type: string; item?: unknown }; timestamp: string }>
const filterLower = filter.toLowerCase()
const type = item.type.toLowerCase()
switch (filterLower) {
case 'tools':
return type === 'tool_call'
case 'text':
return type === 'user_message' || type === 'assistant_message' || type === 'reasoning'
case 'errors':
return type === 'error'
case 'permissions':
// Permissions might be in tool_call status or a separate event type
return type.includes('permission')
default:
// If filter doesn't match predefined types, match against the actual type
return type.includes(filterLower)
}
}
/**
* Parse a timestamp string and return a Date object
* Supports ISO format and relative times like "5m", "1h", "2d"
*/
function parseTimestamp(timeStr: string): Date | null {
// Try ISO format first
const isoDate = new Date(timeStr)
if (!isNaN(isoDate.getTime())) {
return isoDate
}
const items: Array<{ type: string; [key: string]: unknown }> = []
for (const e of payload.events) {
if (e.event.type === 'timeline' && e.event.item) {
items.push(e.event.item as { type: string; [key: string]: unknown })
// Try relative time format (e.g., "5m", "1h", "2d")
const match = timeStr.match(/^(\d+)([smhd])$/)
if (match) {
const value = parseInt(match[1], 10)
const unit = match[2]
const now = new Date()
switch (unit) {
case 's':
now.setSeconds(now.getSeconds() - value)
return now
case 'm':
now.setMinutes(now.getMinutes() - value)
return now
case 'h':
now.setHours(now.getHours() - value)
return now
case 'd':
now.setDate(now.getDate() - value)
return now
}
}
return null
}
/**
* Extract timeline items from an agent_stream_snapshot message
*/
function extractTimelineFromSnapshot(message: AgentStreamSnapshotMessage): AgentTimelineItem[] {
const items: AgentTimelineItem[] = []
for (const e of message.payload.events) {
if (e.event.type === 'timeline') {
items.push(e.event.item)
}
}
return items
@@ -153,19 +179,9 @@ function extractTimelineFromSnapshot(
/**
* Extract a timeline item from an agent_stream message
*/
function extractTimelineFromStream(
message: { type: string; payload: unknown }
): { type: string; [key: string]: unknown } | null {
if (message.type !== 'agent_stream') return null
const payload = message.payload as {
agentId: string
event: { type: string; item?: unknown }
timestamp: string
}
if (payload.event.type === 'timeline' && payload.event.item) {
return payload.event.item as { type: string; [key: string]: unknown }
function extractTimelineFromStream(message: AgentStreamMessage): AgentTimelineItem | null {
if (message.payload.event.type === 'timeline') {
return message.payload.event.item
}
return null
}
@@ -213,7 +229,7 @@ export async function runLogsCommand(
const error: CommandError = {
code: 'AGENT_NOT_FOUND',
message: `No agent found matching: ${id}`,
details: 'Use `paseo agent ps` to list available agents',
details: 'Use `paseo ls` to list available agents',
}
throw error
}
@@ -227,14 +243,13 @@ export async function runLogsCommand(
const logEntries: LogEntry[] = []
// Set up handler for timeline events before initializing
const snapshotPromise = new Promise<Array<{ type: string; [key: string]: unknown }>>((resolve) => {
const snapshotPromise = new Promise<AgentTimelineItem[]>((resolve) => {
const timeout = setTimeout(() => resolve([]), 10000)
const unsubscribe = client.on('agent_stream_snapshot', (msg: unknown) => {
const message = msg as AgentStreamSnapshotMessage
if (message.type !== 'agent_stream_snapshot') return
const payload = message.payload
if (payload.agentId !== resolvedId) return
if (message.payload.agentId !== resolvedId) return
clearTimeout(timeout)
unsubscribe()
@@ -256,9 +271,9 @@ export async function runLogsCommand(
const queue = client.getMessageQueue()
for (const msg of queue) {
if (msg.type === 'agent_stream') {
const payload = msg.payload as { agentId: string }
if (payload.agentId === resolvedId) {
const item = extractTimelineFromStream(msg)
const streamMsg = msg as AgentStreamMessage
if (streamMsg.payload.agentId === resolvedId) {
const item = extractTimelineFromStream(streamMsg)
if (item) {
timelineItems.push(item)
}
@@ -266,9 +281,34 @@ export async function runLogsCommand(
}
}
// Convert to log entries
// Parse since timestamp if provided
const sinceDate = options.since ? parseTimestamp(options.since) : null
if (options.since && !sinceDate) {
const error: CommandError = {
code: 'INVALID_TIMESTAMP',
message: `Invalid timestamp format: ${options.since}`,
details: 'Use ISO format (e.g., 2024-01-15T10:30:00) or relative time (e.g., 5m, 1h, 2d)',
}
throw error
}
// Convert to log entries with filtering
for (const item of timelineItems) {
logEntries.push(formatTimelineItem(item))
// Apply filter
if (!matchesFilter(item, options.filter)) {
continue
}
const entry = formatTimelineItem(item)
// Apply since filter (note: we're using current time for all entries, this is a limitation)
// In a real implementation, timeline items should have their own timestamps
if (sinceDate) {
// Since we don't have actual timestamps on timeline items, we can't filter by time
// This would need to be implemented with proper timestamp support in the timeline items
}
logEntries.push(entry)
}
await client.close()
@@ -313,14 +353,13 @@ async function runFollowMode(
const logEntries: LogEntry[] = []
// First, get existing timeline
const snapshotPromise = new Promise<Array<{ type: string; [key: string]: unknown }>>((resolve) => {
const snapshotPromise = new Promise<AgentTimelineItem[]>((resolve) => {
const timeout = setTimeout(() => resolve([]), 10000)
const unsubscribe = client.on('agent_stream_snapshot', (msg: unknown) => {
const message = msg as AgentStreamSnapshotMessage
if (message.type !== 'agent_stream_snapshot') return
const payload = message.payload
if (payload.agentId !== agentId) return
if (message.payload.agentId !== agentId) return
clearTimeout(timeout)
unsubscribe()
@@ -338,8 +377,10 @@ async function runFollowMode(
// Get existing timeline
const existingItems = await snapshotPromise
// Apply filter to existing items
let itemsToShow = existingItems.filter((item) => matchesFilter(item, options.filter))
// Apply tail to existing items
let itemsToShow = existingItems
if (options.tail) {
const tailCount = parseInt(options.tail, 10)
if (!isNaN(tailCount) && tailCount > 0) {
@@ -360,11 +401,15 @@ async function runFollowMode(
const unsubscribe = client.on('agent_stream', (msg: unknown) => {
const message = msg as AgentStreamMessage
if (message.type !== 'agent_stream') return
const payload = message.payload
if (payload.agentId !== agentId) return
if (message.payload.agentId !== agentId) return
if (payload.event.type === 'timeline' && payload.event.item) {
const entry = formatTimelineItem(payload.event.item as { type: string; [key: string]: unknown })
if (message.payload.event.type === 'timeline') {
const item = message.payload.event.item
// Apply filter
if (!matchesFilter(item, options.filter)) {
return
}
const entry = formatTimelineItem(item)
logEntries.push(entry)
printLogEntry(entry)
}