@shepai/cli 1.14.2 → 1.15.0

package/dist/src/presentation/cli/commands/agent/delete.command.js

@@ -0,0 +1,49 @@
+/**
+ * Agent Delete Command
+ *
+ * Remove an agent run record from the database.
+ *
+ * Usage:
+ *   shep agent delete <id>
+ */
+import { Command } from 'commander';
+import { container } from '../../../../infrastructure/di/container.js';
+import { DeleteAgentRunUseCase } from '../../../../application/use-cases/agents/delete-agent-run.use-case.js';
+import { colors, messages } from '../../ui/index.js';
+import { resolveAgentRun } from './resolve-run.js';
+export function createDeleteCommand() {
+    return new Command('delete')
+        .description('Delete an agent run record')
+        .argument('<id>', 'Agent run ID (or prefix)')
+        .option('--force', 'Force delete even if running')
+        .action(async (id, opts) => {
+        try {
+            const resolved = await resolveAgentRun(id);
+            if ('error' in resolved) {
+                messages.error(resolved.error);
+                process.exitCode = 1;
+                return;
+            }
+            if (opts.force && resolved.run.status === 'running') {
+                // Force delete: stop first, then delete
+                const { StopAgentRunUseCase } = await import('../../../../application/use-cases/agents/stop-agent-run.use-case.js');
+                const stopUseCase = container.resolve(StopAgentRunUseCase);
+                await stopUseCase.execute(resolved.run.id);
+            }
+            const useCase = container.resolve(DeleteAgentRunUseCase);
+            const result = await useCase.execute(resolved.run.id);
+            if (result.deleted) {
+                messages.success(`Deleted ${colors.accent(resolved.run.id.substring(0, 8))}`);
+            }
+            else {
+                messages.error(result.reason);
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to delete agent run', err);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/presentation/cli/commands/agent/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Agent Command
+ *
+ * Top-level agent command with subcommands for managing and viewing agent runs.
+ *
+ * Usage:
+ *   shep agent [subcommand]
+ *
+ * Subcommands:
+ *   shep agent show <id>     Display details of an agent run
+ *   shep agent ls             List all agent runs
+ *   shep agent stop <id>     Stop a running agent
+ *   shep agent logs <id>     View agent run logs
+ *   shep agent delete <id>   Delete an agent run record
+ */
+import { Command } from 'commander';
+/**
+ * Create the agent command with all subcommands
+ */
+export declare function createAgentCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/presentation/cli/commands/agent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/agent/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAY5C"}

package/dist/src/presentation/cli/commands/agent/index.js

@@ -0,0 +1,38 @@
+/**
+ * Agent Command
+ *
+ * Top-level agent command with subcommands for managing and viewing agent runs.
+ *
+ * Usage:
+ *   shep agent [subcommand]
+ *
+ * Subcommands:
+ *   shep agent show <id>     Display details of an agent run
+ *   shep agent ls             List all agent runs
+ *   shep agent stop <id>     Stop a running agent
+ *   shep agent logs <id>     View agent run logs
+ *   shep agent delete <id>   Delete an agent run record
+ */
+import { Command } from 'commander';
+import { createShowCommand } from './show.command.js';
+import { createLsCommand } from './ls.command.js';
+import { createStopCommand } from './stop.command.js';
+import { createLogsCommand } from './logs.command.js';
+import { createDeleteCommand } from './delete.command.js';
+import { createApproveCommand } from './approve.command.js';
+import { createRejectCommand } from './reject.command.js';
+/**
+ * Create the agent command with all subcommands
+ */
+export function createAgentCommand() {
+    const agent = new Command('agent')
+        .description('Manage and view agent runs')
+        .addCommand(createShowCommand())
+        .addCommand(createLsCommand())
+        .addCommand(createStopCommand())
+        .addCommand(createLogsCommand())
+        .addCommand(createDeleteCommand())
+        .addCommand(createApproveCommand())
+        .addCommand(createRejectCommand());
+    return agent;
+}

package/dist/src/presentation/cli/commands/agent/logs.command.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Agent Logs Command
+ *
+ * View log output for an agent run with efficient streaming.
+ *
+ * Usage:
+ *   shep agent logs <id>         # Print full log
+ *   shep agent logs -f <id>      # Follow (tail -f) using fs.watch
+ *   shep agent logs -n 50 <id>   # Last 50 lines
+ */
+import { Command } from 'commander';
+export declare function createLogsCommand(): Command;
+//# sourceMappingURL=logs.command.d.ts.map

package/dist/src/presentation/cli/commands/agent/logs.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logs.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/agent/logs.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgDpC,wBAAgB,iBAAiB,IAAI,OAAO,CAwH3C"}

package/dist/src/presentation/cli/commands/agent/logs.command.js

@@ -0,0 +1,163 @@
+/**
+ * Agent Logs Command
+ *
+ * View log output for an agent run with efficient streaming.
+ *
+ * Usage:
+ *   shep agent logs <id>         # Print full log
+ *   shep agent logs -f <id>      # Follow (tail -f) using fs.watch
+ *   shep agent logs -n 50 <id>   # Last 50 lines
+ */
+import { Command } from 'commander';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { closeSync, createReadStream, existsSync, openSync, readFileSync, readSync, statSync, watch, } from 'node:fs';
+import { open } from 'node:fs/promises';
+import { colors, messages } from '../../ui/index.js';
+import { resolveAgentRun } from './resolve-run.js';
+/** Read the last N lines from a file without loading it all into memory */
+function readTailLines(filePath, n) {
+    const stat = statSync(filePath);
+    // For small files (< 64KB), just read the whole thing
+    if (stat.size < 65536) {
+        const content = readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        return lines.slice(Math.max(0, lines.length - n)).join('\n');
+    }
+    // For large files, read from the end in chunks
+    const fd = openSync(filePath, 'r');
+    const chunkSize = Math.min(stat.size, 8192);
+    let found = 0;
+    let pos = stat.size;
+    let tail = '';
+    const buf = Buffer.alloc(chunkSize);
+    while (pos > 0 && found <= n) {
+        const readSize = Math.min(chunkSize, pos);
+        pos -= readSize;
+        readSync(fd, buf, 0, readSize, pos);
+        const chunk = buf.toString('utf-8', 0, readSize);
+        tail = chunk + tail;
+        for (const ch of chunk) {
+            if (ch === '\n')
+                found++;
+        }
+    }
+    closeSync(fd);
+    const lines = tail.split('\n');
+    return lines.slice(Math.max(0, lines.length - n)).join('\n');
+}
+export function createLogsCommand() {
+    return new Command('logs')
+        .description('View agent run logs')
+        .argument('<id>', 'Agent run ID (or prefix)')
+        .option('-f, --follow', 'Follow log output (like tail -f)')
+        .option('-n, --lines <count>', 'Number of lines to show from the end', '0')
+        .action(async (id, opts) => {
+        try {
+            const resolved = await resolveAgentRun(id);
+            if ('error' in resolved) {
+                messages.error(resolved.error);
+                process.exitCode = 1;
+                return;
+            }
+            const logPath = join(homedir(), '.shep', 'logs', `worker-${resolved.run.id}.log`);
+            if (!existsSync(logPath)) {
+                messages.error(`No log file found for run ${resolved.run.id.substring(0, 8)}`);
+                messages.info(`Expected: ${logPath}`);
+                process.exitCode = 1;
+                return;
+            }
+            const stat = statSync(logPath);
+            if (stat.size === 0) {
+                messages.info(`Log file is empty for run ${colors.accent(resolved.run.id.substring(0, 8))}`);
+                if (!opts.follow)
+                    return;
+                // In follow mode, continue — the file will grow
+            }
+            const requestedLines = parseInt(opts.lines, 10);
+            if (opts.follow) {
+                // Print existing content first
+                if (stat.size > 0) {
+                    if (requestedLines > 0) {
+                        process.stdout.write(readTailLines(logPath, requestedLines));
+                        if (!process.stdout.destroyed)
+                            process.stdout.write('\n');
+                    }
+                    else {
+                        // Stream existing content without loading entire file into memory
+                        await new Promise((resolve, reject) => {
+                            const stream = createReadStream(logPath, { encoding: 'utf-8' });
+                            stream.pipe(process.stdout, { end: false });
+                            stream.on('end', resolve);
+                            stream.on('error', reject);
+                        });
+                    }
+                }
+                // Follow new content using fs.watch (event-driven, no polling)
+                let position = stat.size;
+                const handle = await open(logPath, 'r');
+                // Reusable 4KB buffer for incremental reads
+                const readBuf = Buffer.alloc(4096);
+                const readNewContent = async () => {
+                    try {
+                        const currentStat = statSync(logPath);
+                        while (position < currentStat.size) {
+                            const bytesToRead = Math.min(readBuf.length, currentStat.size - position);
+                            const { bytesRead } = await handle.read(readBuf, 0, bytesToRead, position);
+                            if (bytesRead === 0)
+                                break;
+                            process.stdout.write(readBuf.toString('utf-8', 0, bytesRead));
+                            position += bytesRead;
+                        }
+                    }
+                    catch {
+                        // File may have been deleted/rotated
+                    }
+                };
+                // Use fs.watch for efficient OS-level file change notifications
+                const watcher = watch(logPath, { persistent: true }, () => {
+                    readNewContent();
+                });
+                // Fallback poll every 2s in case fs.watch misses events (NFS, etc.)
+                const fallbackInterval = setInterval(readNewContent, 2000);
+                const cleanup = async () => {
+                    watcher.close();
+                    clearInterval(fallbackInterval);
+                    await handle.close();
+                };
+                process.on('SIGINT', async () => {
+                    await cleanup();
+                    process.exit(0);
+                });
+                process.on('SIGTERM', async () => {
+                    await cleanup();
+                    process.exit(0);
+                });
+            }
+            else {
+                // Print mode
+                if (requestedLines > 0) {
+                    process.stdout.write(readTailLines(logPath, requestedLines));
+                    process.stdout.write('\n');
+                }
+                else {
+                    // Stream the file — don't load it all into memory
+                    await new Promise((resolve, reject) => {
+                        const stream = createReadStream(logPath, { encoding: 'utf-8' });
+                        stream.pipe(process.stdout, { end: false });
+                        stream.on('end', () => {
+                            process.stdout.write('\n');
+                            resolve();
+                        });
+                        stream.on('error', reject);
+                    });
+                }
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to read agent logs', err);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/presentation/cli/commands/agent/ls.command.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agent List Command
+ *
+ * List all agent runs with their status, PID, and other relevant details.
+ * Auto-detects dead PIDs and shows them as "crashed" instead of "running".
+ *
+ * Usage:
+ *   shep agent ls
+ */
+import { Command } from 'commander';
+export declare function createLsCommand(): Command;
+//# sourceMappingURL=ls.command.d.ts.map

package/dist/src/presentation/cli/commands/agent/ls.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ls.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/agent/ls.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAepC,wBAAgB,eAAe,IAAI,OAAO,CAqCzC"}

package/dist/src/presentation/cli/commands/agent/ls.command.js

@@ -0,0 +1,111 @@
+/**
+ * Agent List Command
+ *
+ * List all agent runs with their status, PID, and other relevant details.
+ * Auto-detects dead PIDs and shows them as "crashed" instead of "running".
+ *
+ * Usage:
+ *   shep agent ls
+ */
+import { Command } from 'commander';
+import { container } from '../../../../infrastructure/di/container.js';
+import { ListAgentRunsUseCase } from '../../../../application/use-cases/agents/list-agent-runs.use-case.js';
+import { colors, symbols, messages, renderListView } from '../../ui/index.js';
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function createLsCommand() {
+    return new Command('ls').description('List all agent runs').action(async () => {
+        try {
+            const useCase = container.resolve(ListAgentRunsUseCase);
+            const agentRuns = await useCase.execute();
+            const rows = agentRuns.map((run) => {
+                const liveness = getLiveness(run);
+                return [
+                    run.id.substring(0, 8),
+                    run.agentName,
+                    liveness.displayStatus,
+                    getDuration(run),
+                    run.pid ? String(run.pid) : colors.muted('-'),
+                    liveness.warning || '',
+                ];
+            });
+            renderListView({
+                title: 'Agent Runs',
+                columns: [
+                    { label: 'ID', width: 10 },
+                    { label: 'Agent', width: 18 },
+                    { label: 'Status', width: 16 },
+                    { label: 'Duration', width: 10 },
+                    { label: 'PID', width: 8 },
+                    { label: 'Warning', width: 20 },
+                ],
+                rows,
+                emptyMessage: 'No agent runs found',
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to list agent runs', err);
+            process.exitCode = 1;
+        }
+    });
+}
+function getLiveness(run) {
+    const isActive = run.status === 'running' || run.status === 'pending';
+    if (isActive && run.pid && !isProcessAlive(run.pid)) {
+        return {
+            displayStatus: `${colors.error(symbols.error)} ${colors.error('crashed')}`,
+            warning: colors.error(`PID ${run.pid} dead`),
+        };
+    }
+    const map = {
+        pending: `${colors.muted(symbols.dotEmpty)} ${colors.muted('pending')}`,
+        running: `${colors.info(symbols.dot)} ${colors.info('running')}`,
+        completed: `${colors.success(symbols.success)} ${colors.success('completed')}`,
+        failed: `${colors.error(symbols.error)} ${colors.error('failed')}`,
+        interrupted: `${colors.error(symbols.error)} ${colors.error('interrupted')}`,
+        cancelled: `${colors.muted(symbols.dotEmpty)} ${colors.muted('cancelled')}`,
+    };
+    const displayStatus = map[run.status] || colors.muted(run.status);
+    let warning = '';
+    if (run.status === 'pending' && !run.startedAt) {
+        const hours = (Date.now() - new Date(run.createdAt).getTime()) / (1000 * 60 * 60);
+        if (hours > 24)
+            warning = colors.error('STUCK (>24h)');
+        else if (hours > 1)
+            warning = colors.error('SLOW (>1h)');
+    }
+    return { displayStatus, warning };
+}
+function getDuration(run) {
+    if (run.status === 'pending' && !run.startedAt) {
+        return fmtDuration(Date.now() - new Date(run.createdAt).getTime());
+    }
+    if (run.startedAt && run.completedAt) {
+        return fmtDuration(new Date(run.completedAt).getTime() - new Date(run.startedAt).getTime());
+    }
+    if (run.startedAt) {
+        return fmtDuration(Date.now() - new Date(run.startedAt).getTime());
+    }
+    return '-';
+}
+function fmtDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ${hours % 24}h`;
+    if (hours > 0)
+        return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0)
+        return `${minutes}m`;
+    return `${seconds}s`;
+}

package/dist/src/presentation/cli/commands/agent/reject.command.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Agent Reject Command
+ *
+ * Rejects a paused agent run (waiting_approval) and cancels it.
+ *
+ * Usage:
+ *   shep agent reject <id> [--reason <text>]
+ */
+import { Command } from 'commander';
+export declare function createRejectCommand(): Command;
+//# sourceMappingURL=reject.command.d.ts.map

package/dist/src/presentation/cli/commands/agent/reject.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reject.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/agent/reject.command.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,wBAAgB,mBAAmB,IAAI,OAAO,CA+B7C"}

package/dist/src/presentation/cli/commands/agent/reject.command.js

@@ -0,0 +1,43 @@
+/**
+ * Agent Reject Command
+ *
+ * Rejects a paused agent run (waiting_approval) and cancels it.
+ *
+ * Usage:
+ *   shep agent reject <id> [--reason <text>]
+ */
+import { Command } from 'commander';
+import { container } from '../../../../infrastructure/di/container.js';
+import { RejectAgentRunUseCase } from '../../../../application/use-cases/agents/reject-agent-run.use-case.js';
+import { colors, messages } from '../../ui/index.js';
+import { resolveAgentRun } from './resolve-run.js';
+export function createRejectCommand() {
+    return new Command('reject')
+        .description('Reject a paused agent run and cancel it')
+        .argument('<id>', 'Agent run ID (or prefix)')
+        .option('-r, --reason <text>', 'Reason for rejection')
+        .action(async (id, opts) => {
+        try {
+            const resolved = await resolveAgentRun(id);
+            if ('error' in resolved) {
+                messages.error(resolved.error);
+                process.exitCode = 1;
+                return;
+            }
+            const useCase = container.resolve(RejectAgentRunUseCase);
+            const result = await useCase.execute(resolved.run.id, opts.reason);
+            if (result.rejected) {
+                messages.success(`Rejected ${colors.accent(resolved.run.id.substring(0, 8))}: ${result.reason}`);
+            }
+            else {
+                messages.error(result.reason);
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to reject agent run', err);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/presentation/cli/commands/agent/resolve-run.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared helper: resolve an agent run by exact or prefix ID.
+ */
+import type { AgentRun } from '../../../../domain/generated/output.js';
+export declare function resolveAgentRun(id: string): Promise<{
+    run: AgentRun;
+} | {
+    error: string;
+}>;
+//# sourceMappingURL=resolve-run.d.ts.map

package/dist/src/presentation/cli/commands/agent/resolve-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-run.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/agent/resolve-run.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wCAAwC,CAAC;AAEvE,wBAAsB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,GAAG,EAAE,QAAQ,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAsBhG"}

package/dist/src/presentation/cli/commands/agent/resolve-run.js

@@ -0,0 +1,27 @@
+/**
+ * Shared helper: resolve an agent run by exact or prefix ID.
+ */
+import { container } from '../../../../infrastructure/di/container.js';
+import { GetAgentRunUseCase } from '../../../../application/use-cases/agents/get-agent-run.use-case.js';
+import { ListAgentRunsUseCase } from '../../../../application/use-cases/agents/list-agent-runs.use-case.js';
+export async function resolveAgentRun(id) {
+    const getUseCase = container.resolve(GetAgentRunUseCase);
+    // Try exact match first
+    const exact = await getUseCase.execute(id);
+    if (exact)
+        return { run: exact };
+    // Try prefix match
+    if (id.length < 36) {
+        const listUseCase = container.resolve(ListAgentRunsUseCase);
+        const allRuns = await listUseCase.execute();
+        const matches = allRuns.filter((r) => r.id.startsWith(id));
+        if (matches.length === 1)
+            return { run: matches[0] };
+        if (matches.length > 1) {
+            return {
+                error: `Multiple runs match prefix "${id}": ${matches.map((m) => m.id.substring(0, 8)).join(', ')}`,
+            };
+        }
+    }
+    return { error: `Agent run not found: ${id}` };
+}

package/dist/src/presentation/cli/commands/agent/show.command.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agent Show Command
+ *
+ * Display details of a specific agent run including execution status,
+ * PID, current node, heartbeat, and output.
+ *
+ * Usage:
+ *   shep agent show <id>
+ */
+import { Command } from 'commander';
+export declare function createShowCommand(): Command;
+//# sourceMappingURL=show.command.d.ts.map

package/dist/src/presentation/cli/commands/agent/show.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"show.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/agent/show.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyBpC,wBAAgB,iBAAiB,IAAI,OAAO,CAoG3C"}